entt::observer - how to implement logical OR / AND between matchers?

[eladm-ultrawis]

I have the following components:

struct TransformComponent{};
struct PerspectiveTransformComponent{};
struct CameraRenderUniformBufferComponent{};
struct DirtyTransformComponent{};

I want to my entt::observer to contain the entities that satisfy the following conditions:

(have all of the components: TransformComponent, PerspectiveTransformComponent, CameraRenderUniformBufferComponent)
AND
(TransformComponent is patched OR PerspectiveTransformComponent is patched OR it also has DirtyTransformComponent).

Currently, I managed to make it work somehow with the following incomprehensible statement:

auto updated_cameras_group = entt::collector.update<TransformComponent>().where<TransformComponent, PerspectiveTransformComponent, CameraRenderUniformBufferComponent>().update<PerspectiveTransformComponent>().group<DirtyTransformComponent>();
updated_cameras.connect(registry, updated_cameras_group);

My questions are:

1. Why is this working? I really don't understand how to breakdown this statement.
2. Is there a simpler way to implement what I want?

On a side note, I think entt::observer is a great idea, but:

1. the documentation is super unclear in terms of wording.
2. the documentation lacks examples of combining matchers / conditions.
3. It should be semantically more clear how to implement such behavior.

Thanks!

[skypjack]

The first list is a where clause. The two patched types go into an update clause instead. Here you've your matcher.
The OR it also has token doesn't make much sense. Just create a view for the 4 types and you have the entities that match it.

[eladm-ultrawis]

I apologize, but I didn't understand your answer.

The first list is a where clause. The two patched types go into an update clause instead. Here you've your matcher.

Could you please explain what did you mean? Is my code good? bad? can you give an example?

The OR it also has token doesn't make much sense. Just create a view for the 4 types and you have the entities that match it.

Are you implying that I am better off using a view in addition to the observer? or that using a token is bad altogether? please explain.

[skypjack]

Oh, damn, forgot to answer this one, then vacations got me 😅 sorry for being late.
What I mean is this:

• The first list is a where clause (as in .where<A, B, C>()) because you want these types in all cases no matter what, right? You don't care about them being added in this tick, you want them to be there regardless when the condition finds a match. Is it?
• As for the second list, the first two types can go in an update (as in .update<U, V>()) because you want to know if these types were updated during the last tick or not, do I get it correctly? That's what update is meant for after all, so... 🤷‍♂️
• For what concerns the last type of your second bullet, I probably didn't understand what you wanted. Do you want to know if it was added during the last tick or if it was there since the beginning as for the types in the first list?