Run systems automatically (in Unreal Engine)

[Takao-7]

How could I use a macro to declare a class/struct to be a system and then have that system's "run" function be called automatically in another function, which has a "target" macro (e.g. the game instance's tick function)?

Unreal Engine already uses macros to find Blueprint-exposed classes and structs in your code.

Would this be a reflection system?

[skypjack]

Not sure I get the question to be honest. The EnTT registry is designed as a container, it isn't meant to take over on your systems or loop. So, I don't see how this question relates to the library. Can you elaborate a little further?

[Takao-7]

It is more of a usage or implementation question.

In the example in the documentation, the system is run in the program's main function, by explicitly running the system's loop function.
So if you had a bigger project and lets so you have 50 systems, you would need to run each of theses systems manual somewhere in your code (e.g. manually type in the system's run/update function where it should be run).

My question is, if you know how this process can be automated, so that I don't have to manually run each system, but instead just mark their declaration as being a system, e.g. similar to how you can mark classes in UE4 with UCLASS() and if you do, they will be picked up by UnrealHeaderTool and then you can use the class as a base for a Blueprint class.

Unity's DOTS has the same feature: If you declare a system by inheriting a class from the system base class, the system will be automatically run at runtime.

[skypjack]

In the example in the documentation, the system is run in the program's main function, by explicitly running the system's loop function.
So if you had a bigger project and lets so you have 50 systems, you would need to run each of theses systems manual somewhere in your code (e.g. manually type in the system's run/update function where it should be run).

Well, the example is intentionally minimal and definitely not indicative on how you should do things in large projects. This wouldn't be a good choice for a README file.

My question is, if you know how this process can be automated

It depends on how and where you're using EnTT. If you've a job scheduler on your side, you can use it. If you're combining it with an engine like UE4 or the like, you can use it's job system. Otherwise, you can use something like enkiTs or Taskflow from GitHub. If you don't care about multithreading and you only want a singlethreaded collaborative tool, you can give a look to the process directory of EnTT or, yeah, just have your own loop that runs systems in order. There is nothing wrong with it.

As I said, EnTT ECS part is designed as a container. You can plug and play with it at any time. Though, it's not meant to invert the control and take over the application or part of it, like how you process your systems. Honestly, it would have been easier and the chosen approach is even more challenging at the end of the day, but it's what I wanted and needed, so... 🤷
In a sense, it's like as if you asked how you can schedule your systems now that you're using an std::vector. It's... up to you, really. 🙂 It's also hard to give you a proper answer without knowing more details about the application.

[Takao-7]

It depends on how and where you're using EnTT. If you've a job scheduler on your side, you can use it. If you're combining it with an engine like UE4 or the like, you can use it's job system. Otherwise, you can use something like enkiTs or Taskflow from GitHub. If you don't care about multithreading and you only want a singlethreaded collaborative tool, you can give a look to the process directory of EnTT or, yeah, just have your own loop that runs systems in order. There is nothing wrong with it.

Regardless of how systems are run in the end at runtime, you still have to somehow add/register the system to the scheduler or loop function that in the end runs the system.
And that is my question:
How could I automate the process of registering systems, so that I can just declare a system like this:

USYSTEM()
class UMySystem : public UObject, public ISystem
{
    virtual void RunSystem(float DeltaTime, FRegistry& Registry) override;
};

And this would be picked up before compilation by a reflection system, similar to Unreal Header Tool (I'm not familiar with reflection system, but I think UHT is one?) and then added in a macro, which is placed in the game loop, where it is then run.

Unity DOTS does it, where you only have to inherite a class from a system base class and it is then run automatically. In the system update's function you can explicitly run the code on multiple threads.

Does this makes my question more clearly?

As I said, EnTT ECS part is designed as a container. You can plug and play with it at any time. Though, it's not meant to invert the control and take over the application or part of it, like how you process your systems. Honestly, it would have been easier and the chosen approach is even more challenging at the end of the day, but it's what I wanted and needed, so... 🤷
Mhm, true with the container part.
In that case it would be more of a "can you give examples in the documentation how systems could be run".

It's also hard to give you a proper answer without knowing more details about the application.
Well the application would be a UE4 plugin to integrate EnTT, where you don't have to manually add your systems to a tick function, e.g. by calling a function to add an object or func. pointer to a multicast delegate or by editing a global tick function but just declare them in a file and mark them as being a system.

[skypjack]

The question is clear and I've already answered it.
EnTT does not take control of your loop, there is no way it will ever schedule your systems. You do call EnTT and use its classes, not the other way around. This is a key point of its design, this isn't an engine, but you can find some of the things that you need to roll your own.
The library offers a reflection system, a registry to store entities and components and to query them, a cooperative scheduler and so on, but doesn't put the pieces together for you. It's up to you to do that in the way you like.

[skypjack]

I've just realized that you're last comment was partially covered by the quote. I fixed it.
If your question is how I can do it in C++ rather than how I could do it with EnTT, then there isn't a single answer.
Let's imagine that you decided to use taskflow. In this case, you'll be registering your systems explicitly with a tf::Taskflow object for example. You can automate it, but you've still to understand which system depends on which others and how components are accessed (RO/RW).
As for the automation part, there isn't something built-in in C++. You've to create it or use a pre-cooked library. You can use reflection, register all your systems, then iterate reflected classes and attach them to a scheduler. Or you can use inheritance. The base class will query a central registry from where a scheduler is looked up and will register itself with it, similar to how JNDI works. Otherwise, you can just use inheritance and provide a scheduler to the constructor, that is more invasive to your codebase but also more explicit. And so on. There are tons of solutions.
It's hard to answer this kind of open ended questions, especially if you are looking up for the best solution, because imho there isn't such a thing and it's primarily a matter of tastes.

---

I'm closing the issue because this is better suited for a GH discussion or a chat on gitter/discord if you like. 👍
Feel free to continue here if you prefer, but I'd rather just keep the actual issues open, especially if there is another section for this type of things. 👍
Tell me if you want to convert this thread in a GH discussion and I can do it for you, without having to copy-paste everything. 🙂

[Takao-7]

If your question is how I can do it in C++ rather than how I could do it with EnTT, then there isn't a single answer.

Yes that was the question :)

Let's imagine that you decided to use taskflow. In this case, you'll be registering your systems explicitly with a tf::Taskflow object for example. You can automate it, but you've still to understand which system depends on which others and how components are accessed (RO/RW).
As for the automation part, there isn't something built-in in C++. You've to create it or use a pre-cooked library. You can use reflection, register all your systems, then iterate reflected classes and attach them to a scheduler. Or you can use inheritance. The base class will query a central registry from where a scheduler is looked up and will register itself with it, similar to how JNDI works. Otherwise, you can just use inheritance and provide a scheduler to the constructor, that is more invasive to your codebase but also more explicit. And so on. There are tons of solutions.

👍

By chance, someone mentioned UE4s subsystems today, and it looks like they are exactly what I was looking for.
They get picked up by UnrealHeaderTool automatically and initialized based on their type, which would allow for registering a tick/update function to UE4s ticking system.

I'm closing the issue because this is better suited for a GH discussion or a chat on gitter/discord if you like. 👍
Feel free to continue here if you prefer, but I'd rather just keep the actual issues open, especially if there is another section for this type of things. 👍
Tell me if you want to convert this thread in a GH discussion and I can do it for you, without having to copy-paste everything. 🙂

Yes, a discussion thread would be very good.