265 lines
8 KiB
D
265 lines
8 KiB
D
/************************************************************************************************************************
|
|
System module.
|
|
|
|
Copyright: Copyright © 2018-2023, Dawid Masiukiewicz, Michał Masiukiewicz
|
|
License: BSD 3-clause, see LICENSE file in project root folder.
|
|
*/
|
|
module bubel.ecs.system;
|
|
|
|
import bubel.ecs.entity;
|
|
import bubel.ecs.manager;
|
|
|
|
/************************************************************************************************************************
|
|
System contain data required to proper glue EntityManager with Systems.
|
|
System callbacks:
|
|
$(LIST
|
|
* void onUpdate(EntitesData);
|
|
* void onEnable() - called inside system.enable() function
|
|
* void onDisable() - called inside system.disable() function
|
|
* bool onBegin() - called inside manager.begin()
|
|
* void onEnd() - called inside manager.end()
|
|
* void onCreate() - called after registration inside registerSystem function
|
|
* void onDestroy() - called during re-registration and inside manager destructor
|
|
* void onAddEntity(EntitesData) - called for every entity which are assigned to system (by adding new entity or changing its components)
|
|
* void onRemoveEntity(EntitiesData) - called for every entity removed from system update process
|
|
* void onChangeEntity(EntitiesData) - called for every entity which components are changed but it was previously assigned to system
|
|
* void handleEvent(Entity*, Event) - called for every event supported by system
|
|
)
|
|
*/
|
|
struct System
|
|
{
|
|
|
|
/************************************************************************************************************************
|
|
Check if system is enabled.
|
|
*/
|
|
export bool enabled() nothrow @nogc
|
|
{
|
|
return m_enabled;
|
|
}
|
|
|
|
/************************************************************************************************************************
|
|
Enable system. If actually it is enabled function do nothing.
|
|
*/
|
|
export void enable() nothrow @nogc
|
|
{
|
|
if (!m_enabled && m_enable)
|
|
(cast(void function(void*) nothrow @nogc) m_enable)(m_system_pointer);
|
|
m_enabled = true;
|
|
}
|
|
|
|
/************************************************************************************************************************
|
|
Disable system. If actually it is disabled function do nothing.
|
|
*/
|
|
export void disable() nothrow @nogc
|
|
{
|
|
if (m_enabled && m_disable)
|
|
(cast(void function(void*) nothrow @nogc) m_disable)(m_system_pointer);
|
|
m_enabled = false;
|
|
}
|
|
|
|
/************************************************************************************************************************
|
|
Get system priority.
|
|
*/
|
|
export int priority() nothrow @nogc
|
|
{
|
|
return m_priority;
|
|
}
|
|
|
|
/************************************************************************************************************************
|
|
Get if system will be executed during current frame. Should be checked after manager.begin(). Its value is setted as result of manager.onBegin() callback.
|
|
*/
|
|
export bool willExecute() nothrow @nogc
|
|
{
|
|
return m_execute;
|
|
}
|
|
|
|
/************************************************************************************************************************
|
|
Get system id.
|
|
*/
|
|
export ushort id() nothrow @nogc
|
|
{
|
|
return m_id;
|
|
}
|
|
|
|
/************************************************************************************************************************
|
|
Get system name.
|
|
*/
|
|
export const(char)[] name() nothrow @nogc
|
|
{
|
|
return cast(const(char)[]) m_name;
|
|
}
|
|
|
|
/************************************************************************************************************************
|
|
Return false if system was unregistered, true otherwise.
|
|
*/
|
|
export bool isAlive() nothrow @nogc
|
|
{
|
|
return m_system_pointer != null;
|
|
}
|
|
|
|
/************************************************************************************************************************
|
|
Return pointer to user side system object
|
|
*/
|
|
export void* ptr() nothrow @nogc
|
|
{
|
|
return m_system_pointer;
|
|
}
|
|
|
|
package:
|
|
|
|
///destory system. Dispose all data
|
|
export void destroy() nothrow @nogc
|
|
{
|
|
import bubel.ecs.std : Mallocator;
|
|
|
|
destroySystemData();
|
|
|
|
if (m_name)
|
|
{
|
|
Mallocator.dispose(m_name);
|
|
m_name = null;
|
|
}
|
|
}
|
|
|
|
///destroy all system data but keeps name which is used for case of system re-registration
|
|
void destroySystemData() nothrow @nogc
|
|
{
|
|
import bubel.ecs.std : Mallocator;
|
|
disable();
|
|
if (m_destroy)
|
|
{
|
|
(cast(void function(void*) nothrow @nogc) m_destroy)(m_system_pointer);
|
|
m_destroy = null;
|
|
}
|
|
|
|
if (m_components)
|
|
{
|
|
Mallocator.dispose(m_components);
|
|
m_components = null;
|
|
}
|
|
if (m_excluded_components)
|
|
{
|
|
Mallocator.dispose(m_excluded_components);
|
|
m_excluded_components = null;
|
|
}
|
|
if (m_optional_components)
|
|
{
|
|
Mallocator.dispose(m_optional_components);
|
|
m_optional_components = null;
|
|
}
|
|
if (jobs)
|
|
{
|
|
Mallocator.dispose(jobs);
|
|
jobs = null;
|
|
}
|
|
if (m_read_only_components)
|
|
{
|
|
Mallocator.dispose(m_read_only_components);
|
|
m_read_only_components = null;
|
|
}
|
|
if (m_writable_components)
|
|
{
|
|
Mallocator.dispose(m_writable_components);
|
|
m_writable_components = null;
|
|
}
|
|
if (m_readonly_dependencies)
|
|
{
|
|
Mallocator.dispose(m_readonly_dependencies);
|
|
m_readonly_dependencies = null;
|
|
}
|
|
if (m_writable_dependencies)
|
|
{
|
|
Mallocator.dispose(m_writable_dependencies);
|
|
m_writable_dependencies = null;
|
|
}
|
|
if (m_event_callers)
|
|
{
|
|
Mallocator.dispose(m_event_callers);
|
|
m_event_callers = null;
|
|
}
|
|
|
|
if (m_system_pointer)
|
|
{
|
|
Mallocator.dispose(m_system_pointer);
|
|
m_system_pointer = null;
|
|
}
|
|
}
|
|
|
|
struct EventCaller
|
|
{
|
|
ushort id;
|
|
void* callback;
|
|
}
|
|
|
|
///should system be executed in current update?
|
|
bool m_execute = true;
|
|
///system id
|
|
ushort m_id;
|
|
///is system empty? Empty systems don't update entities, and is called once per update
|
|
bool m_empty = false;
|
|
|
|
///should system update and catch events?
|
|
bool m_enabled = false;
|
|
///system priority
|
|
int m_priority;
|
|
///pointer to system implementation
|
|
void* m_system_pointer;
|
|
///system pass index
|
|
int m_pass;
|
|
|
|
///system name
|
|
char[] m_name;
|
|
|
|
///required components
|
|
ushort[] m_components;
|
|
///excluded components
|
|
ushort[] m_excluded_components;
|
|
///optional components
|
|
ushort[] m_optional_components;
|
|
|
|
EntityManager.Job[] jobs;
|
|
|
|
//System*[] m_dependencies;
|
|
ushort[] m_read_only_components;
|
|
ushort[] m_writable_components;
|
|
|
|
ushort[] m_readonly_dependencies;
|
|
ushort[] m_writable_dependencies;
|
|
|
|
EntityManager.SystemCaller* m_any_system_caller;
|
|
|
|
EventCaller[] m_event_callers;
|
|
|
|
//void function(ref EntityManager.CallData data) m_update;
|
|
void* m_update; ///workaroud for DMD bug with upper line
|
|
void delegate() m_update_delegate;
|
|
|
|
//void function(void* system_pointer) m_enable;
|
|
//void function(void* system_pointer) m_disable;
|
|
|
|
//void function(void* system_pointer) m_create;
|
|
//void function(void* system_pointer) m_destroy;
|
|
|
|
//void function(void* system_pointer) m_begin;
|
|
//void function(void* system_pointer) m_end;
|
|
|
|
void* m_enable;
|
|
void* m_disable;
|
|
|
|
void* m_create;
|
|
void* m_destroy;
|
|
|
|
void* m_begin;
|
|
void* m_end;
|
|
|
|
void* m_add_entity;
|
|
void* m_remove_entity;
|
|
void* m_change_entity;
|
|
|
|
void* m_filter_entity;
|
|
|
|
//void function(ref EntityManager.CallData data) m_initialize;
|
|
//void function(ref EntityManager.CallData data) m_deinitilize;
|
|
void* m_initialize;
|
|
void* m_deinitilize;
|
|
}
|