This page has been translated automatically.
Видеоуроки
Интерфейс
Основы
Продвинутый уровень
Подсказки и советы
Основы
Программирование на C#
Рендеринг
Профессиональный уровень (SIM)
Принципы работы
Свойства (properties)
Компонентная Система
Рендер
Физика
Редактор UnigineEditor
Обзор интерфейса
Работа с ассетами
Контроль версий
Настройки и предпочтения
Работа с проектами
Настройка параметров ноды
Setting Up Materials
Настройка свойств
Освещение
Sandworm
Использование инструментов редактора для конкретных задач
Расширение функционала редактора
Встроенные объекты
Ноды (Nodes)
Объекты (Objects)
Эффекты
Декали
Источники света
Geodetics
World-ноды
Звуковые объекты
Объекты поиска пути
Player-ноды
Программирование
Основы
Настройка среды разработки
Примеры использования
C++
C#
UnigineScript
UUSL (Unified UNIGINE Shader Language)
Плагины
Форматы файлов
Материалы и шейдеры
Rebuilding the Engine Tools
Интерфейс пользователя (GUI)
VR Development
Двойная точность координат
API
Animations-Related Classes
Containers
Common Functionality
Controls-Related Classes
Filesystem Functionality
GUI-Related Classes
Math Functionality
Node-Related Classes
Objects-Related Classes
Networking Functionality
Pathfinding-Related Classes
Physics-Related Classes
Plugins-Related Classes
IG Plugin
CIGIConnector Plugin
Rendering-Related Classes
VR-Related Classes
Работа с контентом
Оптимизация контента
Материалы
Визуальный редактор материалов
Сэмплы материалов
Material Nodes Library
Miscellaneous
Input
Math
Matrix
Textures
Art Samples
Учебные материалы

Unigine::Engine Class

Header: #include <UnigineEngine.h>

The Engine class is required for the engine initialization and executing the main loop of the program. Also, you can get the engine startup options through this class.

The InitParameters structure provides the way to set the following parameters to initialize a new Engine instance:.

Parameter Description
window_title Title of the window.
window_icon_path Path to the window icon.
app_path Path to a directory where binary executable file is stored.
home_path Path to the user's home directory.
project Project name.
password Password for the filesystem archives.
system_proxy Instance of the CustomSystemProxy class.

Engine Class

Enums

BUILD_CONFIG#

Engine build configuration.
ИмяОписание
BUILD_CONFIG_DEBUG = 0Debug build configuration.
BUILD_CONFIG_DEVELOPMENT = 1Development build configuration.
BUILD_CONFIG_RELEASE = 2Release build configuration.

BACKGROUND_UPDATE#

Engine background update mode.
ИмяОписание
BACKGROUND_UPDATE_DISABLED = 0Background update is disabled.
BACKGROUND_UPDATE_RENDER_NON_MINIMIZED = 1Background update is enabled (rendering is performed when the window is out of focus, but stops if the window is minimized).
BACKGROUND_UPDATE_RENDER_ALWAYS = 2Background update is always enabled (rendering is performed all the time, regardless of the window state.

PRECISION#

engine precision type.
ИмяОписание
PRECISION_PRECISION_FLOAT = 0Float precision type.
PRECISION_PRECISION_DOUBLE = 1Double precision type.

Members

isInitialized() const#

Returns the current value indicating whether the engine is initialized or not.

Return value

Current

isInitialized() const#

Returns the current garbage collection mode.

Return value

Current

getAppPath() const#

Returns the current path to a directory where binary executable file is stored.

Return value

Current

getDataPath() const#

Returns the current path to the data directory.

Return value

Current

getHomePath() const#

Returns the current path to the user's home directory.

Return value

Current

getSavePath() const#

Returns the current path to a directory with the default configuration file, saved files, etc.

Return value

Current

getCachePath() const#

Returns the current path to the directory with cached files.

Return value

Current

getNumPluginPaths() const#

Returns the current number of the specified paths to directories with plugins.

Return value

Current

getSystemScript() const#

Returns the current path to the system script.

Return value

Current

getSystemCache() const#

Returns the current path to the system script cache.

Return value

Current

getEditorCache() const#

Returns the current path to the editor script cache.

Return value

Current

getVideoApp() const#

Returns the current graphics API used for rendering.

Return value

Current

getSoundApp() const#

Returns the current sound API used.

Return value

Current

getExternDefine() const#

Returns the current list of external definitions.

Return value

Current

getFeatures() const#

Returns the current list of features like OpenGL, Direct3D, Microprofile, Geodetic, etc.

Return value

Current

getVersion() const#

Returns the current engine version info.

Return value

Current

getBuildConfig() const#

Returns the current engine build configuration name (Debug, Development, or Release).

Return value

Current

isActive() const#

Returns the current active state of the Engine.

Return value

Current

isFocus() const#

Returns the current value showing if any of the Engine windows is in focus.

Return value

Current

isQuit() const#

Returns the current quitting flag on engine quit.

Return value

Current

getTotalTime() const#

Returns the current total time (in milliseconds) that both rendering and calculating of the frame took (the duration of the main loop in the application execution sequence). Includes update, render, swap and wait GPU.

Return value

Current

getTotalCPUTime() const#

Returns the current total CPU time (in milliseconds) taken to perform calculations for the frame (the duration of the main loop in the application execution sequence). Includes update, render and swap.

Return value

Current

getUpdateTime() const#

Returns the current duration (in milliseconds) of the update phase, during which the objects are prepared for their collision response to be calculated.

Return value

Current

getRenderTime() const#

Returns the current time (in milliseconds) required to prepare all data to be rendered in the current frame and feed rendering commands from the CPU to the GPU. See the Profiler article for details.

Return value

Current

getPresentTime() const#

Returns the current total time (in milliseconds) spent on waiting for the GPU after all calculations on the CPU are completed. See the Profiler article for details.

Return value

Current

getInterfaceTime() const#

Returns the current total accumulative time (in milliseconds) spent on rendering GUI widgets.

Return value

Current

getFrame() const#

Returns the current number of the current engine frame.

Return value

Current

getFps() const#

Returns the current value of the Engine FPS counter.

Return value

Current

getIFps() const#

Returns the current inverse value of the Engine FPS counter (1/FPS).

Return value

Current

getStatisticsFpsMin() const#

Returns the current minimum FPS counter value for the last 600 frames.

Return value

Current

getStatisticsFpsAvg() const#

Returns the current average FPS counter value for the last 600 frames.

Return value

Current

getStatisticsFpsMax() const#

Returns the current maximum FPS counter value for the last 600 frames.

Return value

Current

isMainThread() const#

Returns the current value indicating if the current thread is main.

Return value

Current

Ptr<Player> getMainPlayer() const#

Returns the current current main player.

Return value

Current

isEvaluation() const#

Returns the current value indicating if the current version of the Engine is for evaluation only.

Return value

Current

getNumEditorLogics() const#

Returns the current number of EditorLogic instances.

Return value

Current

getNumWorldLogics() const#

Returns the current number of WorldLogic instances.

Return value

Current

getNumSystemLogics() const#

Returns the current number of SystemLogic instances.

Return value

Current

getNumArgs() const#

Returns the current number of command line arguments.

Return value

Current

getNumPlugins() const#

Returns the current number of loaded plugins.

Return value

Current

Event getEventFocusLost() const#

event triggered when all engine windows lost the focus. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the FocusLost event handler
void focuslost_event_handler()
{
	Log::message("\Handling FocusLost event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections focuslost_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventFocusLost().connect(focuslost_event_connections, focuslost_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventFocusLost().connect(focuslost_event_connections, []() { 
		Log::message("\Handling FocusLost event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
focuslost_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection focuslost_event_connection;

// subscribe for the FocusLost event with a handler function keeping the connection
engine->getEventFocusLost().connect(focuslost_event_connection, focuslost_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
focuslost_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
focuslost_event_connection.setEnabled(true);

// ...

// remove subscription for the FocusLost event via the connection
focuslost_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A FocusLost event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling FocusLost event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventFocusLost().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the FocusLost event with a handler function
engine->getEventFocusLost().connect(focuslost_event_handler);


// remove subscription for the FocusLost event later by the handler function
engine->getEventFocusLost().disconnect(focuslost_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId focuslost_handler_id;

// subscribe for the FocusLost event with a lambda handler function and keeping connection ID
focuslost_handler_id = engine->getEventFocusLost().connect([]() { 
		Log::message("\Handling FocusLost event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventFocusLost().disconnect(focuslost_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all FocusLost events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventFocusLost().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventFocusLost().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventFocusGained() const#

event triggered when any of the engine windows gained the focus. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the FocusGained event handler
void focusgained_event_handler()
{
	Log::message("\Handling FocusGained event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections focusgained_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventFocusGained().connect(focusgained_event_connections, focusgained_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventFocusGained().connect(focusgained_event_connections, []() { 
		Log::message("\Handling FocusGained event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
focusgained_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection focusgained_event_connection;

// subscribe for the FocusGained event with a handler function keeping the connection
engine->getEventFocusGained().connect(focusgained_event_connection, focusgained_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
focusgained_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
focusgained_event_connection.setEnabled(true);

// ...

// remove subscription for the FocusGained event via the connection
focusgained_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A FocusGained event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling FocusGained event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventFocusGained().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the FocusGained event with a handler function
engine->getEventFocusGained().connect(focusgained_event_handler);


// remove subscription for the FocusGained event later by the handler function
engine->getEventFocusGained().disconnect(focusgained_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId focusgained_handler_id;

// subscribe for the FocusGained event with a lambda handler function and keeping connection ID
focusgained_handler_id = engine->getEventFocusGained().connect([]() { 
		Log::message("\Handling FocusGained event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventFocusGained().disconnect(focusgained_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all FocusGained events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventFocusGained().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventFocusGained().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndSwap() const#

event triggered after the swap stage is finished. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndSwap event handler
void endswap_event_handler()
{
	Log::message("\Handling EndSwap event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endswap_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndSwap().connect(endswap_event_connections, endswap_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndSwap().connect(endswap_event_connections, []() { 
		Log::message("\Handling EndSwap event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endswap_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endswap_event_connection;

// subscribe for the EndSwap event with a handler function keeping the connection
engine->getEventEndSwap().connect(endswap_event_connection, endswap_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endswap_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endswap_event_connection.setEnabled(true);

// ...

// remove subscription for the EndSwap event via the connection
endswap_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndSwap event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndSwap event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndSwap().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndSwap event with a handler function
engine->getEventEndSwap().connect(endswap_event_handler);


// remove subscription for the EndSwap event later by the handler function
engine->getEventEndSwap().disconnect(endswap_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endswap_handler_id;

// subscribe for the EndSwap event with a lambda handler function and keeping connection ID
endswap_handler_id = engine->getEventEndSwap().connect([]() { 
		Log::message("\Handling EndSwap event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndSwap().disconnect(endswap_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndSwap events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndSwap().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndSwap().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndDeleteObjects() const#

event triggered after the objects are deleted. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndDeleteObjects event handler
void enddeleteobjects_event_handler()
{
	Log::message("\Handling EndDeleteObjects event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections enddeleteobjects_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndDeleteObjects().connect(enddeleteobjects_event_connections, enddeleteobjects_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndDeleteObjects().connect(enddeleteobjects_event_connections, []() { 
		Log::message("\Handling EndDeleteObjects event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
enddeleteobjects_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection enddeleteobjects_event_connection;

// subscribe for the EndDeleteObjects event with a handler function keeping the connection
engine->getEventEndDeleteObjects().connect(enddeleteobjects_event_connection, enddeleteobjects_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
enddeleteobjects_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
enddeleteobjects_event_connection.setEnabled(true);

// ...

// remove subscription for the EndDeleteObjects event via the connection
enddeleteobjects_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndDeleteObjects event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndDeleteObjects event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndDeleteObjects().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndDeleteObjects event with a handler function
engine->getEventEndDeleteObjects().connect(enddeleteobjects_event_handler);


// remove subscription for the EndDeleteObjects event later by the handler function
engine->getEventEndDeleteObjects().disconnect(enddeleteobjects_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId enddeleteobjects_handler_id;

// subscribe for the EndDeleteObjects event with a lambda handler function and keeping connection ID
enddeleteobjects_handler_id = engine->getEventEndDeleteObjects().connect([]() { 
		Log::message("\Handling EndDeleteObjects event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndDeleteObjects().disconnect(enddeleteobjects_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndDeleteObjects events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndDeleteObjects().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndDeleteObjects().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginDeleteObjects() const#

event triggered before the objects are deleted. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginDeleteObjects event handler
void begindeleteobjects_event_handler()
{
	Log::message("\Handling BeginDeleteObjects event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections begindeleteobjects_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginDeleteObjects().connect(begindeleteobjects_event_connections, begindeleteobjects_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginDeleteObjects().connect(begindeleteobjects_event_connections, []() { 
		Log::message("\Handling BeginDeleteObjects event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
begindeleteobjects_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection begindeleteobjects_event_connection;

// subscribe for the BeginDeleteObjects event with a handler function keeping the connection
engine->getEventBeginDeleteObjects().connect(begindeleteobjects_event_connection, begindeleteobjects_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
begindeleteobjects_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
begindeleteobjects_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginDeleteObjects event via the connection
begindeleteobjects_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginDeleteObjects event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginDeleteObjects event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginDeleteObjects().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginDeleteObjects event with a handler function
engine->getEventBeginDeleteObjects().connect(begindeleteobjects_event_handler);


// remove subscription for the BeginDeleteObjects event later by the handler function
engine->getEventBeginDeleteObjects().disconnect(begindeleteobjects_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId begindeleteobjects_handler_id;

// subscribe for the BeginDeleteObjects event with a lambda handler function and keeping connection ID
begindeleteobjects_handler_id = engine->getEventBeginDeleteObjects().connect([]() { 
		Log::message("\Handling BeginDeleteObjects event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginDeleteObjects().disconnect(begindeleteobjects_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginDeleteObjects events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginDeleteObjects().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginDeleteObjects().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndPluginsSwap() const#

event triggered after the plugin swap() function is called, if it exists. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndPluginsSwap event handler
void endpluginsswap_event_handler()
{
	Log::message("\Handling EndPluginsSwap event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endpluginsswap_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndPluginsSwap().connect(endpluginsswap_event_connections, endpluginsswap_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndPluginsSwap().connect(endpluginsswap_event_connections, []() { 
		Log::message("\Handling EndPluginsSwap event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endpluginsswap_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endpluginsswap_event_connection;

// subscribe for the EndPluginsSwap event with a handler function keeping the connection
engine->getEventEndPluginsSwap().connect(endpluginsswap_event_connection, endpluginsswap_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endpluginsswap_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endpluginsswap_event_connection.setEnabled(true);

// ...

// remove subscription for the EndPluginsSwap event via the connection
endpluginsswap_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndPluginsSwap event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndPluginsSwap event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndPluginsSwap().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndPluginsSwap event with a handler function
engine->getEventEndPluginsSwap().connect(endpluginsswap_event_handler);


// remove subscription for the EndPluginsSwap event later by the handler function
engine->getEventEndPluginsSwap().disconnect(endpluginsswap_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endpluginsswap_handler_id;

// subscribe for the EndPluginsSwap event with a lambda handler function and keeping connection ID
endpluginsswap_handler_id = engine->getEventEndPluginsSwap().connect([]() { 
		Log::message("\Handling EndPluginsSwap event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndPluginsSwap().disconnect(endpluginsswap_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndPluginsSwap events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndPluginsSwap().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndPluginsSwap().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginPluginsSwap() const#

event triggered before the plugin swap() function is called, if it exists. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginPluginsSwap event handler
void beginpluginsswap_event_handler()
{
	Log::message("\Handling BeginPluginsSwap event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections beginpluginsswap_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginPluginsSwap().connect(beginpluginsswap_event_connections, beginpluginsswap_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginPluginsSwap().connect(beginpluginsswap_event_connections, []() { 
		Log::message("\Handling BeginPluginsSwap event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginpluginsswap_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection beginpluginsswap_event_connection;

// subscribe for the BeginPluginsSwap event with a handler function keeping the connection
engine->getEventBeginPluginsSwap().connect(beginpluginsswap_event_connection, beginpluginsswap_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
beginpluginsswap_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
beginpluginsswap_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginPluginsSwap event via the connection
beginpluginsswap_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginPluginsSwap event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginPluginsSwap event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginPluginsSwap().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginPluginsSwap event with a handler function
engine->getEventBeginPluginsSwap().connect(beginpluginsswap_event_handler);


// remove subscription for the BeginPluginsSwap event later by the handler function
engine->getEventBeginPluginsSwap().disconnect(beginpluginsswap_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId beginpluginsswap_handler_id;

// subscribe for the BeginPluginsSwap event with a lambda handler function and keeping connection ID
beginpluginsswap_handler_id = engine->getEventBeginPluginsSwap().connect([]() { 
		Log::message("\Handling BeginPluginsSwap event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginPluginsSwap().disconnect(beginpluginsswap_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginPluginsSwap events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginPluginsSwap().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginPluginsSwap().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndWorldSwap() const#

event triggered after the world logic swap() function is executed. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndWorldSwap event handler
void endworldswap_event_handler()
{
	Log::message("\Handling EndWorldSwap event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endworldswap_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndWorldSwap().connect(endworldswap_event_connections, endworldswap_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndWorldSwap().connect(endworldswap_event_connections, []() { 
		Log::message("\Handling EndWorldSwap event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endworldswap_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endworldswap_event_connection;

// subscribe for the EndWorldSwap event with a handler function keeping the connection
engine->getEventEndWorldSwap().connect(endworldswap_event_connection, endworldswap_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endworldswap_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endworldswap_event_connection.setEnabled(true);

// ...

// remove subscription for the EndWorldSwap event via the connection
endworldswap_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndWorldSwap event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndWorldSwap event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndWorldSwap().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndWorldSwap event with a handler function
engine->getEventEndWorldSwap().connect(endworldswap_event_handler);


// remove subscription for the EndWorldSwap event later by the handler function
engine->getEventEndWorldSwap().disconnect(endworldswap_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endworldswap_handler_id;

// subscribe for the EndWorldSwap event with a lambda handler function and keeping connection ID
endworldswap_handler_id = engine->getEventEndWorldSwap().connect([]() { 
		Log::message("\Handling EndWorldSwap event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndWorldSwap().disconnect(endworldswap_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndWorldSwap events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndWorldSwap().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndWorldSwap().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginWorldSwap() const#

event triggered before the world logic swap() function is executed. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginWorldSwap event handler
void beginworldswap_event_handler()
{
	Log::message("\Handling BeginWorldSwap event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections beginworldswap_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginWorldSwap().connect(beginworldswap_event_connections, beginworldswap_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginWorldSwap().connect(beginworldswap_event_connections, []() { 
		Log::message("\Handling BeginWorldSwap event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginworldswap_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection beginworldswap_event_connection;

// subscribe for the BeginWorldSwap event with a handler function keeping the connection
engine->getEventBeginWorldSwap().connect(beginworldswap_event_connection, beginworldswap_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
beginworldswap_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
beginworldswap_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginWorldSwap event via the connection
beginworldswap_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginWorldSwap event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginWorldSwap event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginWorldSwap().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginWorldSwap event with a handler function
engine->getEventBeginWorldSwap().connect(beginworldswap_event_handler);


// remove subscription for the BeginWorldSwap event later by the handler function
engine->getEventBeginWorldSwap().disconnect(beginworldswap_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId beginworldswap_handler_id;

// subscribe for the BeginWorldSwap event with a lambda handler function and keeping connection ID
beginworldswap_handler_id = engine->getEventBeginWorldSwap().connect([]() { 
		Log::message("\Handling BeginWorldSwap event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginWorldSwap().disconnect(beginworldswap_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginWorldSwap events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginWorldSwap().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginWorldSwap().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndPathfinding() const#

event triggered after the pathfinding is updated. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndPathfinding event handler
void endpathfinding_event_handler()
{
	Log::message("\Handling EndPathfinding event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endpathfinding_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndPathfinding().connect(endpathfinding_event_connections, endpathfinding_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndPathfinding().connect(endpathfinding_event_connections, []() { 
		Log::message("\Handling EndPathfinding event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endpathfinding_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endpathfinding_event_connection;

// subscribe for the EndPathfinding event with a handler function keeping the connection
engine->getEventEndPathfinding().connect(endpathfinding_event_connection, endpathfinding_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endpathfinding_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endpathfinding_event_connection.setEnabled(true);

// ...

// remove subscription for the EndPathfinding event via the connection
endpathfinding_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndPathfinding event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndPathfinding event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndPathfinding().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndPathfinding event with a handler function
engine->getEventEndPathfinding().connect(endpathfinding_event_handler);


// remove subscription for the EndPathfinding event later by the handler function
engine->getEventEndPathfinding().disconnect(endpathfinding_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endpathfinding_handler_id;

// subscribe for the EndPathfinding event with a lambda handler function and keeping connection ID
endpathfinding_handler_id = engine->getEventEndPathfinding().connect([]() { 
		Log::message("\Handling EndPathfinding event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndPathfinding().disconnect(endpathfinding_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndPathfinding events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndPathfinding().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndPathfinding().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginSwap() const#

event triggered before the swap stage is started. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginSwap event handler
void beginswap_event_handler()
{
	Log::message("\Handling BeginSwap event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections beginswap_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginSwap().connect(beginswap_event_connections, beginswap_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginSwap().connect(beginswap_event_connections, []() { 
		Log::message("\Handling BeginSwap event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginswap_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection beginswap_event_connection;

// subscribe for the BeginSwap event with a handler function keeping the connection
engine->getEventBeginSwap().connect(beginswap_event_connection, beginswap_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
beginswap_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
beginswap_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginSwap event via the connection
beginswap_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginSwap event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginSwap event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginSwap().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginSwap event with a handler function
engine->getEventBeginSwap().connect(beginswap_event_handler);


// remove subscription for the BeginSwap event later by the handler function
engine->getEventBeginSwap().disconnect(beginswap_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId beginswap_handler_id;

// subscribe for the BeginSwap event with a lambda handler function and keeping connection ID
beginswap_handler_id = engine->getEventBeginSwap().connect([]() { 
		Log::message("\Handling BeginSwap event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginSwap().disconnect(beginswap_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginSwap events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginSwap().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginSwap().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndRender() const#

event triggered after the rendering stage is finished. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndRender event handler
void endrender_event_handler()
{
	Log::message("\Handling EndRender event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endrender_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndRender().connect(endrender_event_connections, endrender_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndRender().connect(endrender_event_connections, []() { 
		Log::message("\Handling EndRender event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endrender_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endrender_event_connection;

// subscribe for the EndRender event with a handler function keeping the connection
engine->getEventEndRender().connect(endrender_event_connection, endrender_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endrender_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endrender_event_connection.setEnabled(true);

// ...

// remove subscription for the EndRender event via the connection
endrender_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndRender event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndRender event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndRender().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndRender event with a handler function
engine->getEventEndRender().connect(endrender_event_handler);


// remove subscription for the EndRender event later by the handler function
engine->getEventEndRender().disconnect(endrender_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endrender_handler_id;

// subscribe for the EndRender event with a lambda handler function and keeping connection ID
endrender_handler_id = engine->getEventEndRender().connect([]() { 
		Log::message("\Handling EndRender event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndRender().disconnect(endrender_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndRender events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndRender().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndRender().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndPostRender() const#

event triggered after the post-rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndPostRender event handler
void endpostrender_event_handler()
{
	Log::message("\Handling EndPostRender event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endpostrender_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndPostRender().connect(endpostrender_event_connections, endpostrender_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndPostRender().connect(endpostrender_event_connections, []() { 
		Log::message("\Handling EndPostRender event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endpostrender_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endpostrender_event_connection;

// subscribe for the EndPostRender event with a handler function keeping the connection
engine->getEventEndPostRender().connect(endpostrender_event_connection, endpostrender_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endpostrender_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endpostrender_event_connection.setEnabled(true);

// ...

// remove subscription for the EndPostRender event via the connection
endpostrender_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndPostRender event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndPostRender event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndPostRender().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndPostRender event with a handler function
engine->getEventEndPostRender().connect(endpostrender_event_handler);


// remove subscription for the EndPostRender event later by the handler function
engine->getEventEndPostRender().disconnect(endpostrender_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endpostrender_handler_id;

// subscribe for the EndPostRender event with a lambda handler function and keeping connection ID
endpostrender_handler_id = engine->getEventEndPostRender().connect([]() { 
		Log::message("\Handling EndPostRender event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndPostRender().disconnect(endpostrender_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndPostRender events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndPostRender().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndPostRender().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginPostRender() const#

event triggered before the post-rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginPostRender event handler
void beginpostrender_event_handler()
{
	Log::message("\Handling BeginPostRender event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections beginpostrender_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginPostRender().connect(beginpostrender_event_connections, beginpostrender_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginPostRender().connect(beginpostrender_event_connections, []() { 
		Log::message("\Handling BeginPostRender event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginpostrender_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection beginpostrender_event_connection;

// subscribe for the BeginPostRender event with a handler function keeping the connection
engine->getEventBeginPostRender().connect(beginpostrender_event_connection, beginpostrender_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
beginpostrender_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
beginpostrender_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginPostRender event via the connection
beginpostrender_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginPostRender event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginPostRender event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginPostRender().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginPostRender event with a handler function
engine->getEventBeginPostRender().connect(beginpostrender_event_handler);


// remove subscription for the BeginPostRender event later by the handler function
engine->getEventBeginPostRender().disconnect(beginpostrender_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId beginpostrender_handler_id;

// subscribe for the BeginPostRender event with a lambda handler function and keeping connection ID
beginpostrender_handler_id = engine->getEventBeginPostRender().connect([]() { 
		Log::message("\Handling BeginPostRender event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginPostRender().disconnect(beginpostrender_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginPostRender events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginPostRender().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginPostRender().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndPluginsGui() const#

event triggered after the gui() function of plugins is called. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndPluginsGui event handler
void endpluginsgui_event_handler()
{
	Log::message("\Handling EndPluginsGui event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endpluginsgui_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndPluginsGui().connect(endpluginsgui_event_connections, endpluginsgui_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndPluginsGui().connect(endpluginsgui_event_connections, []() { 
		Log::message("\Handling EndPluginsGui event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endpluginsgui_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endpluginsgui_event_connection;

// subscribe for the EndPluginsGui event with a handler function keeping the connection
engine->getEventEndPluginsGui().connect(endpluginsgui_event_connection, endpluginsgui_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endpluginsgui_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endpluginsgui_event_connection.setEnabled(true);

// ...

// remove subscription for the EndPluginsGui event via the connection
endpluginsgui_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndPluginsGui event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndPluginsGui event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndPluginsGui().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndPluginsGui event with a handler function
engine->getEventEndPluginsGui().connect(endpluginsgui_event_handler);


// remove subscription for the EndPluginsGui event later by the handler function
engine->getEventEndPluginsGui().disconnect(endpluginsgui_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endpluginsgui_handler_id;

// subscribe for the EndPluginsGui event with a lambda handler function and keeping connection ID
endpluginsgui_handler_id = engine->getEventEndPluginsGui().connect([]() { 
		Log::message("\Handling EndPluginsGui event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndPluginsGui().disconnect(endpluginsgui_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndPluginsGui events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndPluginsGui().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndPluginsGui().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginPluginsGui() const#

event triggered before the gui() function of plugins is called. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginPluginsGui event handler
void beginpluginsgui_event_handler()
{
	Log::message("\Handling BeginPluginsGui event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections beginpluginsgui_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginPluginsGui().connect(beginpluginsgui_event_connections, beginpluginsgui_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginPluginsGui().connect(beginpluginsgui_event_connections, []() { 
		Log::message("\Handling BeginPluginsGui event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginpluginsgui_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection beginpluginsgui_event_connection;

// subscribe for the BeginPluginsGui event with a handler function keeping the connection
engine->getEventBeginPluginsGui().connect(beginpluginsgui_event_connection, beginpluginsgui_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
beginpluginsgui_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
beginpluginsgui_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginPluginsGui event via the connection
beginpluginsgui_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginPluginsGui event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginPluginsGui event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginPluginsGui().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginPluginsGui event with a handler function
engine->getEventBeginPluginsGui().connect(beginpluginsgui_event_handler);


// remove subscription for the BeginPluginsGui event later by the handler function
engine->getEventBeginPluginsGui().disconnect(beginpluginsgui_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId beginpluginsgui_handler_id;

// subscribe for the BeginPluginsGui event with a lambda handler function and keeping connection ID
beginpluginsgui_handler_id = engine->getEventBeginPluginsGui().connect([]() { 
		Log::message("\Handling BeginPluginsGui event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginPluginsGui().disconnect(beginpluginsgui_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginPluginsGui events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginPluginsGui().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginPluginsGui().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndRenderWorld() const#

event triggered after the world rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndRenderWorld event handler
void endrenderworld_event_handler()
{
	Log::message("\Handling EndRenderWorld event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endrenderworld_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndRenderWorld().connect(endrenderworld_event_connections, endrenderworld_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndRenderWorld().connect(endrenderworld_event_connections, []() { 
		Log::message("\Handling EndRenderWorld event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endrenderworld_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endrenderworld_event_connection;

// subscribe for the EndRenderWorld event with a handler function keeping the connection
engine->getEventEndRenderWorld().connect(endrenderworld_event_connection, endrenderworld_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endrenderworld_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endrenderworld_event_connection.setEnabled(true);

// ...

// remove subscription for the EndRenderWorld event via the connection
endrenderworld_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndRenderWorld event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndRenderWorld event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndRenderWorld().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndRenderWorld event with a handler function
engine->getEventEndRenderWorld().connect(endrenderworld_event_handler);


// remove subscription for the EndRenderWorld event later by the handler function
engine->getEventEndRenderWorld().disconnect(endrenderworld_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endrenderworld_handler_id;

// subscribe for the EndRenderWorld event with a lambda handler function and keeping connection ID
endrenderworld_handler_id = engine->getEventEndRenderWorld().connect([]() { 
		Log::message("\Handling EndRenderWorld event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndRenderWorld().disconnect(endrenderworld_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndRenderWorld events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndRenderWorld().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndRenderWorld().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginRenderWorld() const#

event triggered before the world rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginRenderWorld event handler
void beginrenderworld_event_handler()
{
	Log::message("\Handling BeginRenderWorld event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections beginrenderworld_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginRenderWorld().connect(beginrenderworld_event_connections, beginrenderworld_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginRenderWorld().connect(beginrenderworld_event_connections, []() { 
		Log::message("\Handling BeginRenderWorld event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginrenderworld_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection beginrenderworld_event_connection;

// subscribe for the BeginRenderWorld event with a handler function keeping the connection
engine->getEventBeginRenderWorld().connect(beginrenderworld_event_connection, beginrenderworld_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
beginrenderworld_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
beginrenderworld_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginRenderWorld event via the connection
beginrenderworld_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginRenderWorld event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginRenderWorld event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginRenderWorld().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginRenderWorld event with a handler function
engine->getEventBeginRenderWorld().connect(beginrenderworld_event_handler);


// remove subscription for the BeginRenderWorld event later by the handler function
engine->getEventBeginRenderWorld().disconnect(beginrenderworld_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId beginrenderworld_handler_id;

// subscribe for the BeginRenderWorld event with a lambda handler function and keeping connection ID
beginrenderworld_handler_id = engine->getEventBeginRenderWorld().connect([]() { 
		Log::message("\Handling BeginRenderWorld event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginRenderWorld().disconnect(beginrenderworld_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginRenderWorld events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginRenderWorld().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginRenderWorld().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndPluginsRender() const#

event triggered after the plugins rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndPluginsRender event handler
void endpluginsrender_event_handler()
{
	Log::message("\Handling EndPluginsRender event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endpluginsrender_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndPluginsRender().connect(endpluginsrender_event_connections, endpluginsrender_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndPluginsRender().connect(endpluginsrender_event_connections, []() { 
		Log::message("\Handling EndPluginsRender event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endpluginsrender_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endpluginsrender_event_connection;

// subscribe for the EndPluginsRender event with a handler function keeping the connection
engine->getEventEndPluginsRender().connect(endpluginsrender_event_connection, endpluginsrender_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endpluginsrender_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endpluginsrender_event_connection.setEnabled(true);

// ...

// remove subscription for the EndPluginsRender event via the connection
endpluginsrender_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndPluginsRender event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndPluginsRender event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndPluginsRender().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndPluginsRender event with a handler function
engine->getEventEndPluginsRender().connect(endpluginsrender_event_handler);


// remove subscription for the EndPluginsRender event later by the handler function
engine->getEventEndPluginsRender().disconnect(endpluginsrender_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endpluginsrender_handler_id;

// subscribe for the EndPluginsRender event with a lambda handler function and keeping connection ID
endpluginsrender_handler_id = engine->getEventEndPluginsRender().connect([]() { 
		Log::message("\Handling EndPluginsRender event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndPluginsRender().disconnect(endpluginsrender_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndPluginsRender events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndPluginsRender().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndPluginsRender().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginPluginsRender() const#

event triggered before the plugins rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginPluginsRender event handler
void beginpluginsrender_event_handler()
{
	Log::message("\Handling BeginPluginsRender event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections beginpluginsrender_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginPluginsRender().connect(beginpluginsrender_event_connections, beginpluginsrender_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginPluginsRender().connect(beginpluginsrender_event_connections, []() { 
		Log::message("\Handling BeginPluginsRender event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginpluginsrender_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection beginpluginsrender_event_connection;

// subscribe for the BeginPluginsRender event with a handler function keeping the connection
engine->getEventBeginPluginsRender().connect(beginpluginsrender_event_connection, beginpluginsrender_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
beginpluginsrender_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
beginpluginsrender_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginPluginsRender event via the connection
beginpluginsrender_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginPluginsRender event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginPluginsRender event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginPluginsRender().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginPluginsRender event with a handler function
engine->getEventBeginPluginsRender().connect(beginpluginsrender_event_handler);


// remove subscription for the BeginPluginsRender event later by the handler function
engine->getEventBeginPluginsRender().disconnect(beginpluginsrender_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId beginpluginsrender_handler_id;

// subscribe for the BeginPluginsRender event with a lambda handler function and keeping connection ID
beginpluginsrender_handler_id = engine->getEventBeginPluginsRender().connect([]() { 
		Log::message("\Handling BeginPluginsRender event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginPluginsRender().disconnect(beginpluginsrender_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginPluginsRender events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginPluginsRender().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginPluginsRender().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndEditorRender() const#

event triggered after the editor rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndEditorRender event handler
void endeditorrender_event_handler()
{
	Log::message("\Handling EndEditorRender event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endeditorrender_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndEditorRender().connect(endeditorrender_event_connections, endeditorrender_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndEditorRender().connect(endeditorrender_event_connections, []() { 
		Log::message("\Handling EndEditorRender event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endeditorrender_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endeditorrender_event_connection;

// subscribe for the EndEditorRender event with a handler function keeping the connection
engine->getEventEndEditorRender().connect(endeditorrender_event_connection, endeditorrender_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endeditorrender_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endeditorrender_event_connection.setEnabled(true);

// ...

// remove subscription for the EndEditorRender event via the connection
endeditorrender_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndEditorRender event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndEditorRender event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndEditorRender().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndEditorRender event with a handler function
engine->getEventEndEditorRender().connect(endeditorrender_event_handler);


// remove subscription for the EndEditorRender event later by the handler function
engine->getEventEndEditorRender().disconnect(endeditorrender_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endeditorrender_handler_id;

// subscribe for the EndEditorRender event with a lambda handler function and keeping connection ID
endeditorrender_handler_id = engine->getEventEndEditorRender().connect([]() { 
		Log::message("\Handling EndEditorRender event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndEditorRender().disconnect(endeditorrender_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndEditorRender events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndEditorRender().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndEditorRender().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginEditorRender() const#

event triggered before the editor rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginEditorRender event handler
void begineditorrender_event_handler()
{
	Log::message("\Handling BeginEditorRender event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections begineditorrender_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginEditorRender().connect(begineditorrender_event_connections, begineditorrender_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginEditorRender().connect(begineditorrender_event_connections, []() { 
		Log::message("\Handling BeginEditorRender event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
begineditorrender_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection begineditorrender_event_connection;

// subscribe for the BeginEditorRender event with a handler function keeping the connection
engine->getEventBeginEditorRender().connect(begineditorrender_event_connection, begineditorrender_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
begineditorrender_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
begineditorrender_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginEditorRender event via the connection
begineditorrender_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginEditorRender event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginEditorRender event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginEditorRender().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginEditorRender event with a handler function
engine->getEventBeginEditorRender().connect(begineditorrender_event_handler);


// remove subscription for the BeginEditorRender event later by the handler function
engine->getEventBeginEditorRender().disconnect(begineditorrender_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId begineditorrender_handler_id;

// subscribe for the BeginEditorRender event with a lambda handler function and keeping connection ID
begineditorrender_handler_id = engine->getEventBeginEditorRender().connect([]() { 
		Log::message("\Handling BeginEditorRender event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginEditorRender().disconnect(begineditorrender_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginEditorRender events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginEditorRender().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginEditorRender().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginRender() const#

event triggered before the rendering stage is started. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginRender event handler
void beginrender_event_handler()
{
	Log::message("\Handling BeginRender event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections beginrender_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginRender().connect(beginrender_event_connections, beginrender_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginRender().connect(beginrender_event_connections, []() { 
		Log::message("\Handling BeginRender event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginrender_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection beginrender_event_connection;

// subscribe for the BeginRender event with a handler function keeping the connection
engine->getEventBeginRender().connect(beginrender_event_connection, beginrender_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
beginrender_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
beginrender_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginRender event via the connection
beginrender_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginRender event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginRender event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginRender().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginRender event with a handler function
engine->getEventBeginRender().connect(beginrender_event_handler);


// remove subscription for the BeginRender event later by the handler function
engine->getEventBeginRender().disconnect(beginrender_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId beginrender_handler_id;

// subscribe for the BeginRender event with a lambda handler function and keeping connection ID
beginrender_handler_id = engine->getEventBeginRender().connect([]() { 
		Log::message("\Handling BeginRender event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginRender().disconnect(beginrender_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginRender events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginRender().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginRender().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndVRRender() const#

event triggered after the VR rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndVRRender event handler
void endvrrender_event_handler()
{
	Log::message("\Handling EndVRRender event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endvrrender_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndVRRender().connect(endvrrender_event_connections, endvrrender_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndVRRender().connect(endvrrender_event_connections, []() { 
		Log::message("\Handling EndVRRender event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endvrrender_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endvrrender_event_connection;

// subscribe for the EndVRRender event with a handler function keeping the connection
engine->getEventEndVRRender().connect(endvrrender_event_connection, endvrrender_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endvrrender_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endvrrender_event_connection.setEnabled(true);

// ...

// remove subscription for the EndVRRender event via the connection
endvrrender_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndVRRender event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndVRRender event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndVRRender().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndVRRender event with a handler function
engine->getEventEndVRRender().connect(endvrrender_event_handler);


// remove subscription for the EndVRRender event later by the handler function
engine->getEventEndVRRender().disconnect(endvrrender_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endvrrender_handler_id;

// subscribe for the EndVRRender event with a lambda handler function and keeping connection ID
endvrrender_handler_id = engine->getEventEndVRRender().connect([]() { 
		Log::message("\Handling EndVRRender event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndVRRender().disconnect(endvrrender_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndVRRender events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndVRRender().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndVRRender().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginVRRender() const#

event triggered before the VR rendering stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginVRRender event handler
void beginvrrender_event_handler()
{
	Log::message("\Handling BeginVRRender event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections beginvrrender_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginVRRender().connect(beginvrrender_event_connections, beginvrrender_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginVRRender().connect(beginvrrender_event_connections, []() { 
		Log::message("\Handling BeginVRRender event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginvrrender_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection beginvrrender_event_connection;

// subscribe for the BeginVRRender event with a handler function keeping the connection
engine->getEventBeginVRRender().connect(beginvrrender_event_connection, beginvrrender_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
beginvrrender_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
beginvrrender_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginVRRender event via the connection
beginvrrender_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginVRRender event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginVRRender event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginVRRender().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginVRRender event with a handler function
engine->getEventBeginVRRender().connect(beginvrrender_event_handler);


// remove subscription for the BeginVRRender event later by the handler function
engine->getEventBeginVRRender().disconnect(beginvrrender_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId beginvrrender_handler_id;

// subscribe for the BeginVRRender event with a lambda handler function and keeping connection ID
beginvrrender_handler_id = engine->getEventBeginVRRender().connect([]() { 
		Log::message("\Handling BeginVRRender event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginVRRender().disconnect(beginvrrender_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginVRRender events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginVRRender().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginVRRender().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventAsyncEndFramePhysics() const#

event triggered after the physics frame in the physics thread. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the AsyncEndFramePhysics event handler
void asyncendframephysics_event_handler()
{
	Log::message("\Handling AsyncEndFramePhysics event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections asyncendframephysics_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventAsyncEndFramePhysics().connect(asyncendframephysics_event_connections, asyncendframephysics_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventAsyncEndFramePhysics().connect(asyncendframephysics_event_connections, []() { 
		Log::message("\Handling AsyncEndFramePhysics event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
asyncendframephysics_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection asyncendframephysics_event_connection;

// subscribe for the AsyncEndFramePhysics event with a handler function keeping the connection
engine->getEventAsyncEndFramePhysics().connect(asyncendframephysics_event_connection, asyncendframephysics_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
asyncendframephysics_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
asyncendframephysics_event_connection.setEnabled(true);

// ...

// remove subscription for the AsyncEndFramePhysics event via the connection
asyncendframephysics_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A AsyncEndFramePhysics event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling AsyncEndFramePhysics event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventAsyncEndFramePhysics().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the AsyncEndFramePhysics event with a handler function
engine->getEventAsyncEndFramePhysics().connect(asyncendframephysics_event_handler);


// remove subscription for the AsyncEndFramePhysics event later by the handler function
engine->getEventAsyncEndFramePhysics().disconnect(asyncendframephysics_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId asyncendframephysics_handler_id;

// subscribe for the AsyncEndFramePhysics event with a lambda handler function and keeping connection ID
asyncendframephysics_handler_id = engine->getEventAsyncEndFramePhysics().connect([]() { 
		Log::message("\Handling AsyncEndFramePhysics event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventAsyncEndFramePhysics().disconnect(asyncendframephysics_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all AsyncEndFramePhysics events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventAsyncEndFramePhysics().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventAsyncEndFramePhysics().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventAsyncBeginFramePhysics() const#

event triggered before the physics frame in the physics thread. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the AsyncBeginFramePhysics event handler
void asyncbeginframephysics_event_handler()
{
	Log::message("\Handling AsyncBeginFramePhysics event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections asyncbeginframephysics_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventAsyncBeginFramePhysics().connect(asyncbeginframephysics_event_connections, asyncbeginframephysics_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventAsyncBeginFramePhysics().connect(asyncbeginframephysics_event_connections, []() { 
		Log::message("\Handling AsyncBeginFramePhysics event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
asyncbeginframephysics_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection asyncbeginframephysics_event_connection;

// subscribe for the AsyncBeginFramePhysics event with a handler function keeping the connection
engine->getEventAsyncBeginFramePhysics().connect(asyncbeginframephysics_event_connection, asyncbeginframephysics_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
asyncbeginframephysics_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
asyncbeginframephysics_event_connection.setEnabled(true);

// ...

// remove subscription for the AsyncBeginFramePhysics event via the connection
asyncbeginframephysics_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A AsyncBeginFramePhysics event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling AsyncBeginFramePhysics event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventAsyncBeginFramePhysics().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the AsyncBeginFramePhysics event with a handler function
engine->getEventAsyncBeginFramePhysics().connect(asyncbeginframephysics_event_handler);


// remove subscription for the AsyncBeginFramePhysics event later by the handler function
engine->getEventAsyncBeginFramePhysics().disconnect(asyncbeginframephysics_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId asyncbeginframephysics_handler_id;

// subscribe for the AsyncBeginFramePhysics event with a lambda handler function and keeping connection ID
asyncbeginframephysics_handler_id = engine->getEventAsyncBeginFramePhysics().connect([]() { 
		Log::message("\Handling AsyncBeginFramePhysics event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventAsyncBeginFramePhysics().disconnect(asyncbeginframephysics_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all AsyncBeginFramePhysics events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventAsyncBeginFramePhysics().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventAsyncBeginFramePhysics().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventSyncEndFramePhysics() const#

event triggered after the physics frame in the main thread. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the SyncEndFramePhysics event handler
void syncendframephysics_event_handler()
{
	Log::message("\Handling SyncEndFramePhysics event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections syncendframephysics_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventSyncEndFramePhysics().connect(syncendframephysics_event_connections, syncendframephysics_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventSyncEndFramePhysics().connect(syncendframephysics_event_connections, []() { 
		Log::message("\Handling SyncEndFramePhysics event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
syncendframephysics_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection syncendframephysics_event_connection;

// subscribe for the SyncEndFramePhysics event with a handler function keeping the connection
engine->getEventSyncEndFramePhysics().connect(syncendframephysics_event_connection, syncendframephysics_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
syncendframephysics_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
syncendframephysics_event_connection.setEnabled(true);

// ...

// remove subscription for the SyncEndFramePhysics event via the connection
syncendframephysics_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A SyncEndFramePhysics event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling SyncEndFramePhysics event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventSyncEndFramePhysics().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the SyncEndFramePhysics event with a handler function
engine->getEventSyncEndFramePhysics().connect(syncendframephysics_event_handler);


// remove subscription for the SyncEndFramePhysics event later by the handler function
engine->getEventSyncEndFramePhysics().disconnect(syncendframephysics_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId syncendframephysics_handler_id;

// subscribe for the SyncEndFramePhysics event with a lambda handler function and keeping connection ID
syncendframephysics_handler_id = engine->getEventSyncEndFramePhysics().connect([]() { 
		Log::message("\Handling SyncEndFramePhysics event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventSyncEndFramePhysics().disconnect(syncendframephysics_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all SyncEndFramePhysics events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventSyncEndFramePhysics().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventSyncEndFramePhysics().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventSyncBeginFramePhysics() const#

event triggered before the physics frame in the main thread. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the SyncBeginFramePhysics event handler
void syncbeginframephysics_event_handler()
{
	Log::message("\Handling SyncBeginFramePhysics event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections syncbeginframephysics_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventSyncBeginFramePhysics().connect(syncbeginframephysics_event_connections, syncbeginframephysics_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventSyncBeginFramePhysics().connect(syncbeginframephysics_event_connections, []() { 
		Log::message("\Handling SyncBeginFramePhysics event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
syncbeginframephysics_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection syncbeginframephysics_event_connection;

// subscribe for the SyncBeginFramePhysics event with a handler function keeping the connection
engine->getEventSyncBeginFramePhysics().connect(syncbeginframephysics_event_connection, syncbeginframephysics_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
syncbeginframephysics_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
syncbeginframephysics_event_connection.setEnabled(true);

// ...

// remove subscription for the SyncBeginFramePhysics event via the connection
syncbeginframephysics_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A SyncBeginFramePhysics event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling SyncBeginFramePhysics event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventSyncBeginFramePhysics().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the SyncBeginFramePhysics event with a handler function
engine->getEventSyncBeginFramePhysics().connect(syncbeginframephysics_event_handler);


// remove subscription for the SyncBeginFramePhysics event later by the handler function
engine->getEventSyncBeginFramePhysics().disconnect(syncbeginframephysics_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId syncbeginframephysics_handler_id;

// subscribe for the SyncBeginFramePhysics event with a lambda handler function and keeping connection ID
syncbeginframephysics_handler_id = engine->getEventSyncBeginFramePhysics().connect([]() { 
		Log::message("\Handling SyncBeginFramePhysics event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventSyncBeginFramePhysics().disconnect(syncbeginframephysics_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all SyncBeginFramePhysics events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventSyncBeginFramePhysics().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventSyncBeginFramePhysics().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginPathfinding() const#

event triggered before the pathfinding module is updated. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginPathfinding event handler
void beginpathfinding_event_handler()
{
	Log::message("\Handling BeginPathfinding event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections beginpathfinding_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginPathfinding().connect(beginpathfinding_event_connections, beginpathfinding_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginPathfinding().connect(beginpathfinding_event_connections, []() { 
		Log::message("\Handling BeginPathfinding event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginpathfinding_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection beginpathfinding_event_connection;

// subscribe for the BeginPathfinding event with a handler function keeping the connection
engine->getEventBeginPathfinding().connect(beginpathfinding_event_connection, beginpathfinding_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
beginpathfinding_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
beginpathfinding_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginPathfinding event via the connection
beginpathfinding_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginPathfinding event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginPathfinding event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginPathfinding().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginPathfinding event with a handler function
engine->getEventBeginPathfinding().connect(beginpathfinding_event_handler);


// remove subscription for the BeginPathfinding event later by the handler function
engine->getEventBeginPathfinding().disconnect(beginpathfinding_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId beginpathfinding_handler_id;

// subscribe for the BeginPathfinding event with a lambda handler function and keeping connection ID
beginpathfinding_handler_id = engine->getEventBeginPathfinding().connect([]() { 
		Log::message("\Handling BeginPathfinding event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginPathfinding().disconnect(beginpathfinding_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginPathfinding events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginPathfinding().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginPathfinding().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndUpdate() const#

event triggered after the update stage is finished. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndUpdate event handler
void endupdate_event_handler()
{
	Log::message("\Handling EndUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndUpdate().connect(endupdate_event_connections, endupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndUpdate().connect(endupdate_event_connections, []() { 
		Log::message("\Handling EndUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endupdate_event_connection;

// subscribe for the EndUpdate event with a handler function keeping the connection
engine->getEventEndUpdate().connect(endupdate_event_connection, endupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the EndUpdate event via the connection
endupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndUpdate event with a handler function
engine->getEventEndUpdate().connect(endupdate_event_handler);


// remove subscription for the EndUpdate event later by the handler function
engine->getEventEndUpdate().disconnect(endupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endupdate_handler_id;

// subscribe for the EndUpdate event with a lambda handler function and keeping connection ID
endupdate_handler_id = engine->getEventEndUpdate().connect([]() { 
		Log::message("\Handling EndUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndUpdate().disconnect(endupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndFilesystemUpdate() const#

event triggered after the filesystem update stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndFilesystemUpdate event handler
void endfilesystemupdate_event_handler()
{
	Log::message("\Handling EndFilesystemUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endfilesystemupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndFilesystemUpdate().connect(endfilesystemupdate_event_connections, endfilesystemupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndFilesystemUpdate().connect(endfilesystemupdate_event_connections, []() { 
		Log::message("\Handling EndFilesystemUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endfilesystemupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endfilesystemupdate_event_connection;

// subscribe for the EndFilesystemUpdate event with a handler function keeping the connection
engine->getEventEndFilesystemUpdate().connect(endfilesystemupdate_event_connection, endfilesystemupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endfilesystemupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endfilesystemupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the EndFilesystemUpdate event via the connection
endfilesystemupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndFilesystemUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndFilesystemUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndFilesystemUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndFilesystemUpdate event with a handler function
engine->getEventEndFilesystemUpdate().connect(endfilesystemupdate_event_handler);


// remove subscription for the EndFilesystemUpdate event later by the handler function
engine->getEventEndFilesystemUpdate().disconnect(endfilesystemupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endfilesystemupdate_handler_id;

// subscribe for the EndFilesystemUpdate event with a lambda handler function and keeping connection ID
endfilesystemupdate_handler_id = engine->getEventEndFilesystemUpdate().connect([]() { 
		Log::message("\Handling EndFilesystemUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndFilesystemUpdate().disconnect(endfilesystemupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndFilesystemUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndFilesystemUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndFilesystemUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginFilesystemUpdate() const#

event triggered before the filesystem update stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginFilesystemUpdate event handler
void beginfilesystemupdate_event_handler()
{
	Log::message("\Handling BeginFilesystemUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections beginfilesystemupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginFilesystemUpdate().connect(beginfilesystemupdate_event_connections, beginfilesystemupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginFilesystemUpdate().connect(beginfilesystemupdate_event_connections, []() { 
		Log::message("\Handling BeginFilesystemUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginfilesystemupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection beginfilesystemupdate_event_connection;

// subscribe for the BeginFilesystemUpdate event with a handler function keeping the connection
engine->getEventBeginFilesystemUpdate().connect(beginfilesystemupdate_event_connection, beginfilesystemupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
beginfilesystemupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
beginfilesystemupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginFilesystemUpdate event via the connection
beginfilesystemupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginFilesystemUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginFilesystemUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginFilesystemUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginFilesystemUpdate event with a handler function
engine->getEventBeginFilesystemUpdate().connect(beginfilesystemupdate_event_handler);


// remove subscription for the BeginFilesystemUpdate event later by the handler function
engine->getEventBeginFilesystemUpdate().disconnect(beginfilesystemupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId beginfilesystemupdate_handler_id;

// subscribe for the BeginFilesystemUpdate event with a lambda handler function and keeping connection ID
beginfilesystemupdate_handler_id = engine->getEventBeginFilesystemUpdate().connect([]() { 
		Log::message("\Handling BeginFilesystemUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginFilesystemUpdate().disconnect(beginfilesystemupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginFilesystemUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginFilesystemUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginFilesystemUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndSpatialUpdate() const#

event triggered after the spatial tree update stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndSpatialUpdate event handler
void endspatialupdate_event_handler()
{
	Log::message("\Handling EndSpatialUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endspatialupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndSpatialUpdate().connect(endspatialupdate_event_connections, endspatialupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndSpatialUpdate().connect(endspatialupdate_event_connections, []() { 
		Log::message("\Handling EndSpatialUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endspatialupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endspatialupdate_event_connection;

// subscribe for the EndSpatialUpdate event with a handler function keeping the connection
engine->getEventEndSpatialUpdate().connect(endspatialupdate_event_connection, endspatialupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endspatialupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endspatialupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the EndSpatialUpdate event via the connection
endspatialupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndSpatialUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndSpatialUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndSpatialUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndSpatialUpdate event with a handler function
engine->getEventEndSpatialUpdate().connect(endspatialupdate_event_handler);


// remove subscription for the EndSpatialUpdate event later by the handler function
engine->getEventEndSpatialUpdate().disconnect(endspatialupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endspatialupdate_handler_id;

// subscribe for the EndSpatialUpdate event with a lambda handler function and keeping connection ID
endspatialupdate_handler_id = engine->getEventEndSpatialUpdate().connect([]() { 
		Log::message("\Handling EndSpatialUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndSpatialUpdate().disconnect(endspatialupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndSpatialUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndSpatialUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndSpatialUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginSpatialUpdate() const#

event triggered before the spatial tree update stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginSpatialUpdate event handler
void beginspatialupdate_event_handler()
{
	Log::message("\Handling BeginSpatialUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections beginspatialupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginSpatialUpdate().connect(beginspatialupdate_event_connections, beginspatialupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginSpatialUpdate().connect(beginspatialupdate_event_connections, []() { 
		Log::message("\Handling BeginSpatialUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginspatialupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection beginspatialupdate_event_connection;

// subscribe for the BeginSpatialUpdate event with a handler function keeping the connection
engine->getEventBeginSpatialUpdate().connect(beginspatialupdate_event_connection, beginspatialupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
beginspatialupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
beginspatialupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginSpatialUpdate event via the connection
beginspatialupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginSpatialUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginSpatialUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginSpatialUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginSpatialUpdate event with a handler function
engine->getEventBeginSpatialUpdate().connect(beginspatialupdate_event_handler);


// remove subscription for the BeginSpatialUpdate event later by the handler function
engine->getEventBeginSpatialUpdate().disconnect(beginspatialupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId beginspatialupdate_handler_id;

// subscribe for the BeginSpatialUpdate event with a lambda handler function and keeping connection ID
beginspatialupdate_handler_id = engine->getEventBeginSpatialUpdate().connect([]() { 
		Log::message("\Handling BeginSpatialUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginSpatialUpdate().disconnect(beginspatialupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginSpatialUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginSpatialUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginSpatialUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndPluginsPostUpdate() const#

event triggered after the plugins postupdate stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndPluginsPostUpdate event handler
void endpluginspostupdate_event_handler()
{
	Log::message("\Handling EndPluginsPostUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endpluginspostupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndPluginsPostUpdate().connect(endpluginspostupdate_event_connections, endpluginspostupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndPluginsPostUpdate().connect(endpluginspostupdate_event_connections, []() { 
		Log::message("\Handling EndPluginsPostUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endpluginspostupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endpluginspostupdate_event_connection;

// subscribe for the EndPluginsPostUpdate event with a handler function keeping the connection
engine->getEventEndPluginsPostUpdate().connect(endpluginspostupdate_event_connection, endpluginspostupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endpluginspostupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endpluginspostupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the EndPluginsPostUpdate event via the connection
endpluginspostupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndPluginsPostUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndPluginsPostUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndPluginsPostUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndPluginsPostUpdate event with a handler function
engine->getEventEndPluginsPostUpdate().connect(endpluginspostupdate_event_handler);


// remove subscription for the EndPluginsPostUpdate event later by the handler function
engine->getEventEndPluginsPostUpdate().disconnect(endpluginspostupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endpluginspostupdate_handler_id;

// subscribe for the EndPluginsPostUpdate event with a lambda handler function and keeping connection ID
endpluginspostupdate_handler_id = engine->getEventEndPluginsPostUpdate().connect([]() { 
		Log::message("\Handling EndPluginsPostUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndPluginsPostUpdate().disconnect(endpluginspostupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndPluginsPostUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndPluginsPostUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndPluginsPostUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginPluginsPostUpdate() const#

event triggered before the plugins postupdate stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginPluginsPostUpdate event handler
void beginpluginspostupdate_event_handler()
{
	Log::message("\Handling BeginPluginsPostUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections beginpluginspostupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginPluginsPostUpdate().connect(beginpluginspostupdate_event_connections, beginpluginspostupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginPluginsPostUpdate().connect(beginpluginspostupdate_event_connections, []() { 
		Log::message("\Handling BeginPluginsPostUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginpluginspostupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection beginpluginspostupdate_event_connection;

// subscribe for the BeginPluginsPostUpdate event with a handler function keeping the connection
engine->getEventBeginPluginsPostUpdate().connect(beginpluginspostupdate_event_connection, beginpluginspostupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
beginpluginspostupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
beginpluginspostupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginPluginsPostUpdate event via the connection
beginpluginspostupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginPluginsPostUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginPluginsPostUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginPluginsPostUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginPluginsPostUpdate event with a handler function
engine->getEventBeginPluginsPostUpdate().connect(beginpluginspostupdate_event_handler);


// remove subscription for the BeginPluginsPostUpdate event later by the handler function
engine->getEventBeginPluginsPostUpdate().disconnect(beginpluginspostupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId beginpluginspostupdate_handler_id;

// subscribe for the BeginPluginsPostUpdate event with a lambda handler function and keeping connection ID
beginpluginspostupdate_handler_id = engine->getEventBeginPluginsPostUpdate().connect([]() { 
		Log::message("\Handling BeginPluginsPostUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginPluginsPostUpdate().disconnect(beginpluginspostupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginPluginsPostUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginPluginsPostUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginPluginsPostUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndEditorPostUpdate() const#

event triggered after the editor logic postupdate stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndEditorPostUpdate event handler
void endeditorpostupdate_event_handler()
{
	Log::message("\Handling EndEditorPostUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endeditorpostupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndEditorPostUpdate().connect(endeditorpostupdate_event_connections, endeditorpostupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndEditorPostUpdate().connect(endeditorpostupdate_event_connections, []() { 
		Log::message("\Handling EndEditorPostUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endeditorpostupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endeditorpostupdate_event_connection;

// subscribe for the EndEditorPostUpdate event with a handler function keeping the connection
engine->getEventEndEditorPostUpdate().connect(endeditorpostupdate_event_connection, endeditorpostupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endeditorpostupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endeditorpostupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the EndEditorPostUpdate event via the connection
endeditorpostupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndEditorPostUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndEditorPostUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndEditorPostUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndEditorPostUpdate event with a handler function
engine->getEventEndEditorPostUpdate().connect(endeditorpostupdate_event_handler);


// remove subscription for the EndEditorPostUpdate event later by the handler function
engine->getEventEndEditorPostUpdate().disconnect(endeditorpostupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endeditorpostupdate_handler_id;

// subscribe for the EndEditorPostUpdate event with a lambda handler function and keeping connection ID
endeditorpostupdate_handler_id = engine->getEventEndEditorPostUpdate().connect([]() { 
		Log::message("\Handling EndEditorPostUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndEditorPostUpdate().disconnect(endeditorpostupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndEditorPostUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndEditorPostUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndEditorPostUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginEditorPostUpdate() const#

event triggered before the editor logic postupdate stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginEditorPostUpdate event handler
void begineditorpostupdate_event_handler()
{
	Log::message("\Handling BeginEditorPostUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections begineditorpostupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginEditorPostUpdate().connect(begineditorpostupdate_event_connections, begineditorpostupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginEditorPostUpdate().connect(begineditorpostupdate_event_connections, []() { 
		Log::message("\Handling BeginEditorPostUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
begineditorpostupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection begineditorpostupdate_event_connection;

// subscribe for the BeginEditorPostUpdate event with a handler function keeping the connection
engine->getEventBeginEditorPostUpdate().connect(begineditorpostupdate_event_connection, begineditorpostupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
begineditorpostupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
begineditorpostupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginEditorPostUpdate event via the connection
begineditorpostupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginEditorPostUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginEditorPostUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginEditorPostUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginEditorPostUpdate event with a handler function
engine->getEventBeginEditorPostUpdate().connect(begineditorpostupdate_event_handler);


// remove subscription for the BeginEditorPostUpdate event later by the handler function
engine->getEventBeginEditorPostUpdate().disconnect(begineditorpostupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId begineditorpostupdate_handler_id;

// subscribe for the BeginEditorPostUpdate event with a lambda handler function and keeping connection ID
begineditorpostupdate_handler_id = engine->getEventBeginEditorPostUpdate().connect([]() { 
		Log::message("\Handling BeginEditorPostUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginEditorPostUpdate().disconnect(begineditorpostupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginEditorPostUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginEditorPostUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginEditorPostUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndSystemLogicPostUpdate() const#

event triggered after the system logic postupdate stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndSystemLogicPostUpdate event handler
void endsystemlogicpostupdate_event_handler()
{
	Log::message("\Handling EndSystemLogicPostUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endsystemlogicpostupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndSystemLogicPostUpdate().connect(endsystemlogicpostupdate_event_connections, endsystemlogicpostupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndSystemLogicPostUpdate().connect(endsystemlogicpostupdate_event_connections, []() { 
		Log::message("\Handling EndSystemLogicPostUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endsystemlogicpostupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endsystemlogicpostupdate_event_connection;

// subscribe for the EndSystemLogicPostUpdate event with a handler function keeping the connection
engine->getEventEndSystemLogicPostUpdate().connect(endsystemlogicpostupdate_event_connection, endsystemlogicpostupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endsystemlogicpostupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endsystemlogicpostupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the EndSystemLogicPostUpdate event via the connection
endsystemlogicpostupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndSystemLogicPostUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndSystemLogicPostUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndSystemLogicPostUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndSystemLogicPostUpdate event with a handler function
engine->getEventEndSystemLogicPostUpdate().connect(endsystemlogicpostupdate_event_handler);


// remove subscription for the EndSystemLogicPostUpdate event later by the handler function
engine->getEventEndSystemLogicPostUpdate().disconnect(endsystemlogicpostupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endsystemlogicpostupdate_handler_id;

// subscribe for the EndSystemLogicPostUpdate event with a lambda handler function and keeping connection ID
endsystemlogicpostupdate_handler_id = engine->getEventEndSystemLogicPostUpdate().connect([]() { 
		Log::message("\Handling EndSystemLogicPostUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndSystemLogicPostUpdate().disconnect(endsystemlogicpostupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndSystemLogicPostUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndSystemLogicPostUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndSystemLogicPostUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginSystemLogicPostUpdate() const#

event triggered before the system logic postupdate stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginSystemLogicPostUpdate event handler
void beginsystemlogicpostupdate_event_handler()
{
	Log::message("\Handling BeginSystemLogicPostUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections beginsystemlogicpostupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginSystemLogicPostUpdate().connect(beginsystemlogicpostupdate_event_connections, beginsystemlogicpostupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginSystemLogicPostUpdate().connect(beginsystemlogicpostupdate_event_connections, []() { 
		Log::message("\Handling BeginSystemLogicPostUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginsystemlogicpostupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection beginsystemlogicpostupdate_event_connection;

// subscribe for the BeginSystemLogicPostUpdate event with a handler function keeping the connection
engine->getEventBeginSystemLogicPostUpdate().connect(beginsystemlogicpostupdate_event_connection, beginsystemlogicpostupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
beginsystemlogicpostupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
beginsystemlogicpostupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginSystemLogicPostUpdate event via the connection
beginsystemlogicpostupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginSystemLogicPostUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginSystemLogicPostUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginSystemLogicPostUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginSystemLogicPostUpdate event with a handler function
engine->getEventBeginSystemLogicPostUpdate().connect(beginsystemlogicpostupdate_event_handler);


// remove subscription for the BeginSystemLogicPostUpdate event later by the handler function
engine->getEventBeginSystemLogicPostUpdate().disconnect(beginsystemlogicpostupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId beginsystemlogicpostupdate_handler_id;

// subscribe for the BeginSystemLogicPostUpdate event with a lambda handler function and keeping connection ID
beginsystemlogicpostupdate_handler_id = engine->getEventBeginSystemLogicPostUpdate().connect([]() { 
		Log::message("\Handling BeginSystemLogicPostUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginSystemLogicPostUpdate().disconnect(beginsystemlogicpostupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginSystemLogicPostUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginSystemLogicPostUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginSystemLogicPostUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndSystemScriptPostUpdate() const#

event triggered after the system script postupdate stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndSystemScriptPostUpdate event handler
void endsystemscriptpostupdate_event_handler()
{
	Log::message("\Handling EndSystemScriptPostUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endsystemscriptpostupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndSystemScriptPostUpdate().connect(endsystemscriptpostupdate_event_connections, endsystemscriptpostupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndSystemScriptPostUpdate().connect(endsystemscriptpostupdate_event_connections, []() { 
		Log::message("\Handling EndSystemScriptPostUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endsystemscriptpostupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endsystemscriptpostupdate_event_connection;

// subscribe for the EndSystemScriptPostUpdate event with a handler function keeping the connection
engine->getEventEndSystemScriptPostUpdate().connect(endsystemscriptpostupdate_event_connection, endsystemscriptpostupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endsystemscriptpostupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endsystemscriptpostupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the EndSystemScriptPostUpdate event via the connection
endsystemscriptpostupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndSystemScriptPostUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndSystemScriptPostUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndSystemScriptPostUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndSystemScriptPostUpdate event with a handler function
engine->getEventEndSystemScriptPostUpdate().connect(endsystemscriptpostupdate_event_handler);


// remove subscription for the EndSystemScriptPostUpdate event later by the handler function
engine->getEventEndSystemScriptPostUpdate().disconnect(endsystemscriptpostupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endsystemscriptpostupdate_handler_id;

// subscribe for the EndSystemScriptPostUpdate event with a lambda handler function and keeping connection ID
endsystemscriptpostupdate_handler_id = engine->getEventEndSystemScriptPostUpdate().connect([]() { 
		Log::message("\Handling EndSystemScriptPostUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndSystemScriptPostUpdate().disconnect(endsystemscriptpostupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndSystemScriptPostUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndSystemScriptPostUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndSystemScriptPostUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginSystemScriptPostUpdate() const#

event triggered before the system script postupdate stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginSystemScriptPostUpdate event handler
void beginsystemscriptpostupdate_event_handler()
{
	Log::message("\Handling BeginSystemScriptPostUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections beginsystemscriptpostupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginSystemScriptPostUpdate().connect(beginsystemscriptpostupdate_event_connections, beginsystemscriptpostupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginSystemScriptPostUpdate().connect(beginsystemscriptpostupdate_event_connections, []() { 
		Log::message("\Handling BeginSystemScriptPostUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginsystemscriptpostupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection beginsystemscriptpostupdate_event_connection;

// subscribe for the BeginSystemScriptPostUpdate event with a handler function keeping the connection
engine->getEventBeginSystemScriptPostUpdate().connect(beginsystemscriptpostupdate_event_connection, beginsystemscriptpostupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
beginsystemscriptpostupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
beginsystemscriptpostupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginSystemScriptPostUpdate event via the connection
beginsystemscriptpostupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginSystemScriptPostUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginSystemScriptPostUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginSystemScriptPostUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginSystemScriptPostUpdate event with a handler function
engine->getEventBeginSystemScriptPostUpdate().connect(beginsystemscriptpostupdate_event_handler);


// remove subscription for the BeginSystemScriptPostUpdate event later by the handler function
engine->getEventBeginSystemScriptPostUpdate().disconnect(beginsystemscriptpostupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId beginsystemscriptpostupdate_handler_id;

// subscribe for the BeginSystemScriptPostUpdate event with a lambda handler function and keeping connection ID
beginsystemscriptpostupdate_handler_id = engine->getEventBeginSystemScriptPostUpdate().connect([]() { 
		Log::message("\Handling BeginSystemScriptPostUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginSystemScriptPostUpdate().disconnect(beginsystemscriptpostupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginSystemScriptPostUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginSystemScriptPostUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginSystemScriptPostUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndWorldPostUpdate() const#

event triggered after the world logic postupdate stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndWorldPostUpdate event handler
void endworldpostupdate_event_handler()
{
	Log::message("\Handling EndWorldPostUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endworldpostupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndWorldPostUpdate().connect(endworldpostupdate_event_connections, endworldpostupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndWorldPostUpdate().connect(endworldpostupdate_event_connections, []() { 
		Log::message("\Handling EndWorldPostUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endworldpostupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endworldpostupdate_event_connection;

// subscribe for the EndWorldPostUpdate event with a handler function keeping the connection
engine->getEventEndWorldPostUpdate().connect(endworldpostupdate_event_connection, endworldpostupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endworldpostupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endworldpostupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the EndWorldPostUpdate event via the connection
endworldpostupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndWorldPostUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndWorldPostUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndWorldPostUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndWorldPostUpdate event with a handler function
engine->getEventEndWorldPostUpdate().connect(endworldpostupdate_event_handler);


// remove subscription for the EndWorldPostUpdate event later by the handler function
engine->getEventEndWorldPostUpdate().disconnect(endworldpostupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endworldpostupdate_handler_id;

// subscribe for the EndWorldPostUpdate event with a lambda handler function and keeping connection ID
endworldpostupdate_handler_id = engine->getEventEndWorldPostUpdate().connect([]() { 
		Log::message("\Handling EndWorldPostUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndWorldPostUpdate().disconnect(endworldpostupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndWorldPostUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndWorldPostUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndWorldPostUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginWorldPostUpdate() const#

event triggered before the world logic postupdate stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginWorldPostUpdate event handler
void beginworldpostupdate_event_handler()
{
	Log::message("\Handling BeginWorldPostUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections beginworldpostupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginWorldPostUpdate().connect(beginworldpostupdate_event_connections, beginworldpostupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginWorldPostUpdate().connect(beginworldpostupdate_event_connections, []() { 
		Log::message("\Handling BeginWorldPostUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginworldpostupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection beginworldpostupdate_event_connection;

// subscribe for the BeginWorldPostUpdate event with a handler function keeping the connection
engine->getEventBeginWorldPostUpdate().connect(beginworldpostupdate_event_connection, beginworldpostupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
beginworldpostupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
beginworldpostupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginWorldPostUpdate event via the connection
beginworldpostupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginWorldPostUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginWorldPostUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginWorldPostUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginWorldPostUpdate event with a handler function
engine->getEventBeginWorldPostUpdate().connect(beginworldpostupdate_event_handler);


// remove subscription for the BeginWorldPostUpdate event later by the handler function
engine->getEventBeginWorldPostUpdate().disconnect(beginworldpostupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId beginworldpostupdate_handler_id;

// subscribe for the BeginWorldPostUpdate event with a lambda handler function and keeping connection ID
beginworldpostupdate_handler_id = engine->getEventBeginWorldPostUpdate().connect([]() { 
		Log::message("\Handling BeginWorldPostUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginWorldPostUpdate().disconnect(beginworldpostupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginWorldPostUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginWorldPostUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginWorldPostUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndAnimationManagerUpdate() const#

event triggered after the animation manager update stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndAnimationManagerUpdate event handler
void endanimationmanagerupdate_event_handler()
{
	Log::message("\Handling EndAnimationManagerUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endanimationmanagerupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndAnimationManagerUpdate().connect(endanimationmanagerupdate_event_connections, endanimationmanagerupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndAnimationManagerUpdate().connect(endanimationmanagerupdate_event_connections, []() { 
		Log::message("\Handling EndAnimationManagerUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endanimationmanagerupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endanimationmanagerupdate_event_connection;

// subscribe for the EndAnimationManagerUpdate event with a handler function keeping the connection
engine->getEventEndAnimationManagerUpdate().connect(endanimationmanagerupdate_event_connection, endanimationmanagerupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endanimationmanagerupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endanimationmanagerupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the EndAnimationManagerUpdate event via the connection
endanimationmanagerupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndAnimationManagerUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndAnimationManagerUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndAnimationManagerUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndAnimationManagerUpdate event with a handler function
engine->getEventEndAnimationManagerUpdate().connect(endanimationmanagerupdate_event_handler);


// remove subscription for the EndAnimationManagerUpdate event later by the handler function
engine->getEventEndAnimationManagerUpdate().disconnect(endanimationmanagerupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endanimationmanagerupdate_handler_id;

// subscribe for the EndAnimationManagerUpdate event with a lambda handler function and keeping connection ID
endanimationmanagerupdate_handler_id = engine->getEventEndAnimationManagerUpdate().connect([]() { 
		Log::message("\Handling EndAnimationManagerUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndAnimationManagerUpdate().disconnect(endanimationmanagerupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndAnimationManagerUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndAnimationManagerUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndAnimationManagerUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginAnimationManagerUpdate() const#

event triggered before the animation manager update stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginAnimationManagerUpdate event handler
void beginanimationmanagerupdate_event_handler()
{
	Log::message("\Handling BeginAnimationManagerUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections beginanimationmanagerupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginAnimationManagerUpdate().connect(beginanimationmanagerupdate_event_connections, beginanimationmanagerupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginAnimationManagerUpdate().connect(beginanimationmanagerupdate_event_connections, []() { 
		Log::message("\Handling BeginAnimationManagerUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginanimationmanagerupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection beginanimationmanagerupdate_event_connection;

// subscribe for the BeginAnimationManagerUpdate event with a handler function keeping the connection
engine->getEventBeginAnimationManagerUpdate().connect(beginanimationmanagerupdate_event_connection, beginanimationmanagerupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
beginanimationmanagerupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
beginanimationmanagerupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginAnimationManagerUpdate event via the connection
beginanimationmanagerupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginAnimationManagerUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginAnimationManagerUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginAnimationManagerUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginAnimationManagerUpdate event with a handler function
engine->getEventBeginAnimationManagerUpdate().connect(beginanimationmanagerupdate_event_handler);


// remove subscription for the BeginAnimationManagerUpdate event later by the handler function
engine->getEventBeginAnimationManagerUpdate().disconnect(beginanimationmanagerupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId beginanimationmanagerupdate_handler_id;

// subscribe for the BeginAnimationManagerUpdate event with a lambda handler function and keeping connection ID
beginanimationmanagerupdate_handler_id = engine->getEventBeginAnimationManagerUpdate().connect([]() { 
		Log::message("\Handling BeginAnimationManagerUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginAnimationManagerUpdate().disconnect(beginanimationmanagerupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginAnimationManagerUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginAnimationManagerUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginAnimationManagerUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndWorldUpdate() const#

event triggered after the world logic update stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndWorldUpdate event handler
void endworldupdate_event_handler()
{
	Log::message("\Handling EndWorldUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endworldupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndWorldUpdate().connect(endworldupdate_event_connections, endworldupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndWorldUpdate().connect(endworldupdate_event_connections, []() { 
		Log::message("\Handling EndWorldUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endworldupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endworldupdate_event_connection;

// subscribe for the EndWorldUpdate event with a handler function keeping the connection
engine->getEventEndWorldUpdate().connect(endworldupdate_event_connection, endworldupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endworldupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endworldupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the EndWorldUpdate event via the connection
endworldupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndWorldUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndWorldUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndWorldUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndWorldUpdate event with a handler function
engine->getEventEndWorldUpdate().connect(endworldupdate_event_handler);


// remove subscription for the EndWorldUpdate event later by the handler function
engine->getEventEndWorldUpdate().disconnect(endworldupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endworldupdate_handler_id;

// subscribe for the EndWorldUpdate event with a lambda handler function and keeping connection ID
endworldupdate_handler_id = engine->getEventEndWorldUpdate().connect([]() { 
		Log::message("\Handling EndWorldUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndWorldUpdate().disconnect(endworldupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndWorldUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndWorldUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndWorldUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginWorldUpdate() const#

event triggered before the world logic update stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginWorldUpdate event handler
void beginworldupdate_event_handler()
{
	Log::message("\Handling BeginWorldUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections beginworldupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginWorldUpdate().connect(beginworldupdate_event_connections, beginworldupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginWorldUpdate().connect(beginworldupdate_event_connections, []() { 
		Log::message("\Handling BeginWorldUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginworldupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection beginworldupdate_event_connection;

// subscribe for the BeginWorldUpdate event with a handler function keeping the connection
engine->getEventBeginWorldUpdate().connect(beginworldupdate_event_connection, beginworldupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
beginworldupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
beginworldupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginWorldUpdate event via the connection
beginworldupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginWorldUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginWorldUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginWorldUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginWorldUpdate event with a handler function
engine->getEventBeginWorldUpdate().connect(beginworldupdate_event_handler);


// remove subscription for the BeginWorldUpdate event later by the handler function
engine->getEventBeginWorldUpdate().disconnect(beginworldupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId beginworldupdate_handler_id;

// subscribe for the BeginWorldUpdate event with a lambda handler function and keeping connection ID
beginworldupdate_handler_id = engine->getEventBeginWorldUpdate().connect([]() { 
		Log::message("\Handling BeginWorldUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginWorldUpdate().disconnect(beginworldupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginWorldUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginWorldUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginWorldUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndSystemLogicUpdate() const#

event triggered after the system logic update stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndSystemLogicUpdate event handler
void endsystemlogicupdate_event_handler()
{
	Log::message("\Handling EndSystemLogicUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endsystemlogicupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndSystemLogicUpdate().connect(endsystemlogicupdate_event_connections, endsystemlogicupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndSystemLogicUpdate().connect(endsystemlogicupdate_event_connections, []() { 
		Log::message("\Handling EndSystemLogicUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endsystemlogicupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endsystemlogicupdate_event_connection;

// subscribe for the EndSystemLogicUpdate event with a handler function keeping the connection
engine->getEventEndSystemLogicUpdate().connect(endsystemlogicupdate_event_connection, endsystemlogicupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endsystemlogicupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endsystemlogicupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the EndSystemLogicUpdate event via the connection
endsystemlogicupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndSystemLogicUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndSystemLogicUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndSystemLogicUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndSystemLogicUpdate event with a handler function
engine->getEventEndSystemLogicUpdate().connect(endsystemlogicupdate_event_handler);


// remove subscription for the EndSystemLogicUpdate event later by the handler function
engine->getEventEndSystemLogicUpdate().disconnect(endsystemlogicupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endsystemlogicupdate_handler_id;

// subscribe for the EndSystemLogicUpdate event with a lambda handler function and keeping connection ID
endsystemlogicupdate_handler_id = engine->getEventEndSystemLogicUpdate().connect([]() { 
		Log::message("\Handling EndSystemLogicUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndSystemLogicUpdate().disconnect(endsystemlogicupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndSystemLogicUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndSystemLogicUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndSystemLogicUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginSystemLogicUpdate() const#

event triggered before the system logic update stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginSystemLogicUpdate event handler
void beginsystemlogicupdate_event_handler()
{
	Log::message("\Handling BeginSystemLogicUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections beginsystemlogicupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginSystemLogicUpdate().connect(beginsystemlogicupdate_event_connections, beginsystemlogicupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginSystemLogicUpdate().connect(beginsystemlogicupdate_event_connections, []() { 
		Log::message("\Handling BeginSystemLogicUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginsystemlogicupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection beginsystemlogicupdate_event_connection;

// subscribe for the BeginSystemLogicUpdate event with a handler function keeping the connection
engine->getEventBeginSystemLogicUpdate().connect(beginsystemlogicupdate_event_connection, beginsystemlogicupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
beginsystemlogicupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
beginsystemlogicupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginSystemLogicUpdate event via the connection
beginsystemlogicupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginSystemLogicUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginSystemLogicUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginSystemLogicUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginSystemLogicUpdate event with a handler function
engine->getEventBeginSystemLogicUpdate().connect(beginsystemlogicupdate_event_handler);


// remove subscription for the BeginSystemLogicUpdate event later by the handler function
engine->getEventBeginSystemLogicUpdate().disconnect(beginsystemlogicupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId beginsystemlogicupdate_handler_id;

// subscribe for the BeginSystemLogicUpdate event with a lambda handler function and keeping connection ID
beginsystemlogicupdate_handler_id = engine->getEventBeginSystemLogicUpdate().connect([]() { 
		Log::message("\Handling BeginSystemLogicUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginSystemLogicUpdate().disconnect(beginsystemlogicupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginSystemLogicUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginSystemLogicUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginSystemLogicUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndSystemScriptUpdate() const#

event triggered after the system script update stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndSystemScriptUpdate event handler
void endsystemscriptupdate_event_handler()
{
	Log::message("\Handling EndSystemScriptUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endsystemscriptupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndSystemScriptUpdate().connect(endsystemscriptupdate_event_connections, endsystemscriptupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndSystemScriptUpdate().connect(endsystemscriptupdate_event_connections, []() { 
		Log::message("\Handling EndSystemScriptUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endsystemscriptupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endsystemscriptupdate_event_connection;

// subscribe for the EndSystemScriptUpdate event with a handler function keeping the connection
engine->getEventEndSystemScriptUpdate().connect(endsystemscriptupdate_event_connection, endsystemscriptupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endsystemscriptupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endsystemscriptupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the EndSystemScriptUpdate event via the connection
endsystemscriptupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndSystemScriptUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndSystemScriptUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndSystemScriptUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndSystemScriptUpdate event with a handler function
engine->getEventEndSystemScriptUpdate().connect(endsystemscriptupdate_event_handler);


// remove subscription for the EndSystemScriptUpdate event later by the handler function
engine->getEventEndSystemScriptUpdate().disconnect(endsystemscriptupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endsystemscriptupdate_handler_id;

// subscribe for the EndSystemScriptUpdate event with a lambda handler function and keeping connection ID
endsystemscriptupdate_handler_id = engine->getEventEndSystemScriptUpdate().connect([]() { 
		Log::message("\Handling EndSystemScriptUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndSystemScriptUpdate().disconnect(endsystemscriptupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndSystemScriptUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndSystemScriptUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndSystemScriptUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginSystemScriptUpdate() const#

event triggered before the system script update stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the BeginSystemScriptUpdate event handler
void beginsystemscriptupdate_event_handler()
{
	Log::message("\Handling BeginSystemScriptUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections beginsystemscriptupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventBeginSystemScriptUpdate().connect(beginsystemscriptupdate_event_connections, beginsystemscriptupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventBeginSystemScriptUpdate().connect(beginsystemscriptupdate_event_connections, []() { 
		Log::message("\Handling BeginSystemScriptUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
beginsystemscriptupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection beginsystemscriptupdate_event_connection;

// subscribe for the BeginSystemScriptUpdate event with a handler function keeping the connection
engine->getEventBeginSystemScriptUpdate().connect(beginsystemscriptupdate_event_connection, beginsystemscriptupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
beginsystemscriptupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
beginsystemscriptupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the BeginSystemScriptUpdate event via the connection
beginsystemscriptupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A BeginSystemScriptUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling BeginSystemScriptUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventBeginSystemScriptUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the BeginSystemScriptUpdate event with a handler function
engine->getEventBeginSystemScriptUpdate().connect(beginsystemscriptupdate_event_handler);


// remove subscription for the BeginSystemScriptUpdate event later by the handler function
engine->getEventBeginSystemScriptUpdate().disconnect(beginsystemscriptupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId beginsystemscriptupdate_handler_id;

// subscribe for the BeginSystemScriptUpdate event with a lambda handler function and keeping connection ID
beginsystemscriptupdate_handler_id = engine->getEventBeginSystemScriptUpdate().connect([]() { 
		Log::message("\Handling BeginSystemScriptUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventBeginSystemScriptUpdate().disconnect(beginsystemscriptupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all BeginSystemScriptUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventBeginSystemScriptUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventBeginSystemScriptUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventEndEditorUpdate() const#

event triggered after the editor update stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use EventConnection  and EventConnections  classes for convenience (see examples below).

Usage Example

Source code (C++)
// implement the EndEditorUpdate event handler
void endeditorupdate_event_handler()
{
	Log::message("\Handling EndEditorUpdate event\n");
}


//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an instance of the EventConnections 
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections endeditorupdate_event_connections;

// link to this instance when subscribing for an event (subscription for various events can be linked)
engine->getEventEndEditorUpdate().connect(endeditorupdate_event_connections, endeditorupdate_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
engine->getEventEndEditorUpdate().connect(endeditorupdate_event_connections, []() { 
		Log::message("\Handling EndEditorUpdate event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
endeditorupdate_event_connections.disconnectAll();

//////////////////////////////////////////////////////////////////////////////
//  2. You can subscribe and unsubscribe via an instance of the EventConnection 
//  class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnection class
EventConnection endeditorupdate_event_connection;

// subscribe for the EndEditorUpdate event with a handler function keeping the connection
engine->getEventEndEditorUpdate().connect(endeditorupdate_event_connection, endeditorupdate_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
endeditorupdate_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
endeditorupdate_event_connection.setEnabled(true);

// ...

// remove subscription for the EndEditorUpdate event via the connection
endeditorupdate_event_connection.disconnect();

//////////////////////////////////////////////////////////////////////////////
//  3. You can add EventConnection/EventConnections instance as a member of the
//  class that handles the event. In this case all linked subscriptions will be 
//  automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////

// Class handling the event
class SomeClass
{
public:
	// instance of the EventConnections class as a class member
	EventConnections e_connections;

	// A EndEditorUpdate event handler implemented as a class member
	void event_handler()
	{
		Log::message("\Handling EndEditorUpdate event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
engine->getEventEndEditorUpdate().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;

//////////////////////////////////////////////////////////////////////////////
//  4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe for the EndEditorUpdate event with a handler function
engine->getEventEndEditorUpdate().connect(endeditorupdate_event_handler);


// remove subscription for the EndEditorUpdate event later by the handler function
engine->getEventEndEditorUpdate().disconnect(endeditorupdate_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////

// define a connection ID to be used to unsubscribe later
EventConnectionId endeditorupdate_handler_id;

// subscribe for the EndEditorUpdate event with a lambda handler function and keeping connection ID
endeditorupdate_handler_id = engine->getEventEndEditorUpdate().connect([]() { 
		Log::message("\Handling EndEditorUpdate event (lambda).\n");
	}
);

// remove the subscription later using the ID
engine->getEventEndEditorUpdate().disconnect(endeditorupdate_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all EndEditorUpdate events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
engine->getEventEndEditorUpdate().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
engine->getEventEndEditorUpdate().setEnabled(true);
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Return value

Current

Event getEventBeginEditorUpdate() const#

event triggered before the editor update stage. You can subscribe to events via connect()  and unsubscribe via disconnect(). You can also use