does registry.any_of<...> cause any mayor overhead?

[rudiHammad]

Hello,
so my question is pretty much in the title.
I am making motion systems, and I don't know if I should do one motionsystem to handle different motioncomponent types, or one motionsystem per component. Here is a pseudo code:

#include <entt/entt.hpp>
#include <iostream>


// Motion components
struct LinearComponent {
    float velocityX;
    float velocityY;
};

struct CurveComponent {
    float amplitude;
    float frequency;
};

struct RadialComponent {
    float speed;
};

//... more


// System
void MotionSystem(entt::registry& registry) {
    // Create a view of all entities that have any of the components
    auto view = registry.view<LinearComponent, CurveComponent, RadialComponent>();

    for (auto entity : view) {

        if (registry.any_of<LinearComponent>(entity)) {
            auto& linear = registry.get<LinearComponent>(entity);
            // linear motion code
        }

        else if (registry.any_of<CurveComponent>(entity)) {
            auto& curve = registry.get<CurveComponent>(entity);
            // curve motion code
        }

        else if (registry.any_of<RadialComponent>(entity);) {
            auto& radial = registry.get<RadialComponent>(entity);
           // radial motion code
       
       // else until reaching the last type of motion
        }

        // more
    }
}

The benefit of this is that I only have one system to manage, but i don't know at what cost. Since they are simple equations I think this should be okey? but I am just guessing.

thanks

[skypjack]

Well, technically speaking, all_of has to lookup the storage and check if it contains the entity.
Although barely measurable, it's faster to get the storage from the view since you have it already. For example:

if (view.storage<LinearComponent>().contains(entity)) { ... }

That said, your loop looks wrong to me. Briefly, the view returns all the entities that have LinearComponent AND CurveComponent AND RadialComponent. Therefore, only the first if is entered.

[rudiHammad]

you're right, I did the loop really fast without much though.
The code bellow I assume that is also wrong

 struct MotionSystem
{
public:
    
    MotionSystem() {};

    void update(float delta, entt::registry& registry)
    {
        auto view = registry.view<LinearComponent, ParabolicComponent, CurveComponent>();

        for (auto entity : view)
        {
            if (view.storage<LinearComponent>().contains(entity))
            {
                // 
            }

            if (view.storage<ParabolicComponent>().contains(entity))
            {
                // 
            }

            if (view.storage<CurveComponent>().contains(entity))
            {
                // 
            }
        }
    }
};

it is wrong because auto view = registry.view<LinearComponent, ParabolicComponent, CurveComponent>();
is forcing the view to have all the components, since as you mentioned, it means that the entity has LinearComponent and ParabolicComponent and CurveComponent? So this time i am entering all if statements.

Then isn't this the only solution:

struct MotionSystem
{
public:
    
    MotionSystem() {};

    void update(float delta, entt::registry& registry)
    {
        auto viewLinearComponents = registry.view<LinearComponent>();
        auto viewParabolicComponents = registry.view<ParabolicComponent>();
        auto viewCurveComponents     = registry.view<CurveComponent>();

        for (auto entity : viewLinearComponents)
        {
            //...
        }

        for (auto entity : viewParabolicComponents)
        {
            //...
        }

        for (auto entity : viewCurveComponents)
        {
            //...
        }

    }
};

or this one, which I thing is what you suggest with registry.all_of

struct MotionSystem
{
public:
    
    MotionSystem() {};

    void update(float delta, entt::registry& registry)
    {
        registry.each([&] (auto entity)
        {
            if(registry.all_of<LinearComponent>(entity))
            {
                
            }

            if (registry.all_of<ParabolicComponent>(entity))
            {
            }

            if (registry.all_of<CurveComponent>(entity))
            {
            }
        });
    }

};

Thanks

[skypjack]

Let me flip the question on its head and ask you: what are you trying to achieve? 🙂
The latter looks like the only solution but I don't know what the original problem is, so it's hard to say if it's right or not actually.
Iterating all entities is almost always wrong in my experience. Therefore, you're probably doing something wrong here.
However, I can't really help without knowing what the goal is. You know... 🤷‍♂️

[rudiHammad]

Sure. I make games with Entt and Axmol (a cocos2dx fork). So I am programming my Core Components and Systems at the moment (just started). I want to make them as "atomic" as possible. So I have a simple PositionComponent that has a x and y data. I want those coordinates to be modified by a MotionSystem, that will make the entities (a cloud, a rock, a spaceship, ....) move differently. Here is some pseudo code (I don't have a finished one yet)

// In my main scene I have this
#include "ecs/components/transformComponents.h"  // this has the PositionComponent struct
#include "ecs/systems/motionSystems.h"


bool Scene::init()
{
//...
// Setting the components
auto entity_A = registry.create();
registry.emplace<PositionComponent>(entity_A, 0, 0);                   // where 0, 0 are x and y
registry.emplace<LinearComponent>(entity_A, 2, 0, 100);  // where 2 is the slope value, 0 the y offset and 100  the speed

// Setting the system
registry.ctx().emplace<MotionSystem>(registry);    // which is the one from the code from my previous post

// ...
)

void Scene::update(float delta)
{
      registry.ctx().emplace<MotionSystem>().update(delta, registry);
}

so going back to the previous code adding some logic

struct MotionSystem
{
public:

    MotionSystem() {};

    void update(float delta, entt::registry& registry)
    {
        registry.each([&] (auto entity)
        {
            if(registry.all_of<LinearComponent>(entity))
            {
                auto& pos = view.get<PositionComponent>(entity);
                auto linearCmp = view.get<LinearComponent>(entity);
                pos.x += linearCmp.speed * delta;
                pos.y += linearCmp.m * pos.x  + linearCmp.p;    // so basically a line equation y = m*x + p
            }

            if (registry.all_of<ParabolicComponent>(entity))
            {
                  // process parabolic movement
            }

            if (registry.all_of<CurveComponent>(entity))
            {
                // process curve (or what ever) movement
            }

          //  more motion types
        });
    }

};

I hope this make my intent more clear. So when ever I have an entity that I want to move different, I would add the Component motion I want, and let the unique MotionSystem process it.

auto entity_B = registry.create();
registry.emplace<PositionComponent>(entity_B, 0, 0);                   
registry.emplace<ParabolicMotion>(entity_B, ..... );  

[skypjack]

Why not three loops then? It's much faster then iterating all entities with a cascade of ifs. I mean something like this:

void update(float delta, entt::registry& registry) {
    for(auto [entt, elem]: registry.view<LinearComponent>().each()) {
        // process linear movement
    }

    for(auto [entt, elem]: registry.view<ParabolicComponent>().each()) {
        // process parabolic movement
    }

    for(auto [entt, elem]: registry.view<CurveComponent>().each()) {
        // process curve (or what ever) movement
    }
}

Or even three different systems. I don't get why you should iterate all entities and check if they have the right component. Views already do it for you in a sense.

[rudiHammad]

Well that's the point of asking 🙂, to know if what I am doing is fast or slow. I am fairly new to entt and C++ so there is plenty I don't know yet.
About not having the three systems, it is to make it easier to manage, otherwise with every new type of motion, I have to do a new system. So I would end with LinearMotionSystem, ParabolicMotionSystem, CircleMotionSystem, ExponentialMotionSystem, SquareRootMotionSystem, SinusoidalMotionSystem, etc....
Unless having all that is much faster that the loops... As far as I know, if a storage is empty, skipping entering the loop is fast enough to avoid having a system for each. But of course, please correct me if I am wrong.

Finally what you suggested is similar to what I mentioned previously right?

// This...
for(auto [entt, elem]: registry.view<LinearComponent>().each())
 {
        // process linear movement
  }

//... and this are the same?
auto viewLinearComponents = registry.view<LinearComponent>();
for (auto entity : viewLinearComponents)
 {
            //...
 }

I know it is obvious they are the same, only you iterate both at the same. Ther reason I ask, is because I remember reading some where about creating unnecessary variable (which would be what I did with auto viewLinearComponents = registry.view()).
But, it was said that this is okey because it helps readability and the compiler is smart enough, so it won't have any penalty.
(I am talking in general term, not referring to what you suggested, which is very readable).

Thanks again for you help.

[skypjack]

Unless having all that is much faster that the loops...

Uhm, no, it's mainly a matter of tastes. I prefer more small systems but it's me, that's why I suggested it. 🙂

if a storage is empty, skipping entering the loop is fast enough to avoid having a system for each

Don't waste your time checking if a storage is empty. Just construct views and iterate them. If the storage is empty, they return immediately anyway. EnTT isn't like many other libraries that have hidden costs everywhere and force you to avoid this kind of things.

Finally what you suggested is similar to what I mentioned previously right?

Yes, it's similar. However, iterating entities and getting components separately is slightly more expensive than iterating everything at once. In the last case, EnTT knows that you want both and can optimize accesses. In the first case, it doesn't know if you're going to also get the component and therefore it cannot help.
That said, the difference is barely measurable probably and it would be great if that was your performance problem in a game. So, use the approach that you like more without caring much about all this. 👍

[rudiHammad]

awesome. All good then. Thanks for your explanations and time.
cheers!