Entity Debugger feedback

So there is a way to see entities already...
I think instead of "entity 1" it should be name of i.e. archetype of this entity if exist. It will be more transparent if you will see i.e. "player archetype" so you can easily see whats going on.

 

Entities don't have names, they are just a number.

For now, you could create a marking component (IComponentData with 0 fields) and a system that uses that marker but does nothing with it. With the current debugger you could find your marking system to list all of the entities that have that marker.

 

Any chance we can get a view showing the order of execution of the systems soon? I can see this being a pain point.

 

Useful workaround but doesn't it spam debugger with fake systems? I'm still wondering if debugger can check i.e. archetype of entity. You instantiate whole archetype, so it should be possible, isn't it?

 

ECS doesn't really care what the archetype is, it is just the starting list of components added to the entity. Having the editor track which archetype was used at creation would be a nice feature.

As for the workaround, I think we will find that any system that is used in only one archetype will work so you really don't need the marker container/system that often. During development I think I will create a Debug group (when needed) to keep these kinds of things in. Not only would that help organize the debugger information but would allow me to schedule it after everything else if I want to do any debug logging.

As I am gaining understanding of this paradigm I really like the flexibility. It will be incredibly easy to 'whip out' at debugging system specific to your use case using the exact same tools you do for the rest of your application.

 

So far Entity Debugger is quite nice that able to observe what entities have been used inside a observed system. The next thing to improve will be:
1) Make entity able to modify component data at inspector just like modify data at MonoBehaviour when in play mode
2) Make the view (things can see from scene) spawns at the scene and link with the entity to make it able know that the particular view is corresponding to which entity. It will have the button and when pressing it will jump to the Entity Debugger and auto direct and highlight all the systems that use the entity.

 

+ Entity centric display

 

I think this is already kind of implict though just by seeing the name of the system. I mean, it would be a really odd bug if somehow the system grabbed a component that wasn't explicitly intended for it. I dont think that could really even happen.

So you kind of already know just by selecting the system. I suppose it would make it more explicit, though.

 

Sorry for the off-topic, but could you clean that window up soon? It's already three quarters of my screen tall in an empty project, and every new Unity update seems to add another entry. There's also a lot of asset store packages that adds their own entries, and we'd like to have our own windows in there as well. It's getting pretty hard to find things!

 

I can agree with that. My current monitor is 1366x768 max resolution and that menu dropdown is well over my screen. It is pretty bloated.

 

*leans in and whispers* and clean up the Project Window context menu too please. Its getting absurd at this point

 

Btw any chance will implement this feature? I think not only showing execution order is important but also make it easier to setup and see all systems in one central place is essential too. https://forum.unity.com/threads/request-more-elegant-way-to-setup-execution-order-of-systems.522946/

 

Another thing is have you consider about code generation as one of the direction to go? https://forum.unity.com/threads/code-generation.523040/#post-3434802

 

Naming things is the hardest part of programming.

I like the idea of editor-only components. Ideally, for naming, the developer would write a function or system that sets the name with "Entity ##" as the default. The only problem with using a ComponentSystem is dealing with strings of unknown length.

 

Constraints are code, right? So you're setting up a UI to change the code? That'd be great.

 

@Daniel-Brauer, I found another 6 improvements that are quite important.

1) Display all the systems that haven been created with the correct order without needing to enter play mode.
2) Entity Debugger has a Entity tab to show all the available entities when entering play mode.
3) Ability to set time threshold and the system will mark as red when the time taken to execute over the time threshold.
4) Visualize all the systems in details that will tell whether it's update or fixed update system, group of systems (parent system and sub system), ComponentSystem, JobComponentSystem, order of systems, sync point and etc.
5) Add search input field into Entity Debugger that able to search specific system or entity and filter out redundant system or entity based on keyword.
6) Entity Debugger has a Memory Layout tab that visualize the memory layout of entities to make it easier to setup archetype.

 

And also double click on a system opens the c# file at the right line

 

Ok, no idea how this will work together so you got me curious!

 

How about adding optional "EntityNameComponent" to Entity? If this component is on Entity, then in EntityDebugger entity shows with this name, else it has "Entity #" name. And sort entities by name. (Entities without name goes after entities with name).

 

Will it really to make it overcomplicate the UI that make it works in non-play mode? Instead of display systems of Editor World,

it will directly display Default World and any other actual World

It's just like the search bar at Profiler that it will filter out things for you when u type keyword. For example, u type Position2D, PlayerInput space Position2D, Health, Enemy then other systems will be filter out and left only EntityManager, EnemyShootSystem and EnemyRemovalSystem.

One more thing I forget is to visualize parallel systems.

 

I would like to see is only all the initial systems that you will see when u just hit play mode. So,no Entities and only systems will be displayed. Of course, if able to set execution order of systems in one center place instead of setting individual system with attribute then I think this feature is not really require anymore.

 

Great feedback from one of the ECS expert: https://medium.com/@icex33/my-wish-list-for-unity3d-ecs-1f3985bbe308. One thing he mentions about is Reactive System and I think it is very important missing feature in current Unity ECS. I really hope I can use Reactive System in next Entities package version updates.

 

As some people already mentioned I would really like to be able to inspect and maybe change the ComponentData for a specific entity. Also the current way of listing systems and showing their used ComponentGroups and the entities within that group is quite useful. If I could now select that entity and get a list of ComponentData (ideally editable) that would be very handy.

 

The Reactive System I expect is:

It will have a place to setup what ComponentData u wish to react to. For this example code, if there is Sprite Component add/replace to the entity, it will enter this system.

Code (CSharp):

1. protected override ICollector<GameEntity> GetTrigger(IContext<GameEntity> context)
2.  
3.    {
4.  
5.        return context.CreateCollector(GameMatcher.Sprite);
6.  
7.    }

Then it will further check whether the entity has sprite component and does not have view component.

Code (CSharp):

1. protected override bool Filter(GameEntity entity)
2.  
3.    {
4.  
5.        return entity.hasSprite && !entity.hasView;
6.  
7.    }

If everything meets the requirement, it will execute the system code.

Code (CSharp):

1. protected override void Execute(List<GameEntity> entities)
2.  
3.    {
4.  
5.        foreach (GameEntity e in entities)
6.  
7.        {
8.  
9.            GameObject go = new GameObject("Game View");
10.  
11.            go.transform.SetParent(_viewContainer, false);
12.  
13.            e.AddView(go);
14.  
15.            go.Link(e, _context);
16.  
17.        }
18.  
19.    }

 

That looks a lot like entitas. In Unity's scenario I would expect something like a [ChangedOnly] attribute that will inject only entities whose data has changed. So for instance the TransformUpdateSystem could do something like this:

Code (CSharp):

1. public struct Group
2.     {
3.         [ChangedOnly] public ComponentDataArray<Position> positions;
4.         public ComponentDataArray<TransformMatrix> matrices;
5.     }

And then receive only entities that have both a TransformMatrix and a Position where the Position was changed.

 

No, i wasn't aware of that. Will check tonight. I thought I was only able to see entities/archetypes per system. Hm let me guess i can make the window even wider and will see what i wanted?

 

Ah damn. At home I'm limited to my Macbook's screen estate so in my layout i actually was tabbing between inspector and entity debugger window....

 

Wouldn't be so much of a problem if I would have known that. THe hierarchy view is pretty useless anyway when doing pure ecs. Ideally this could all be somehow displayed in the hierarchy anyway. Otherwise I imagine it's going to be a bit weird when dealing with complex transform hierarchies (which we will still have).

 

1) ability to tweak systems order
2) ability to tweak components values
3) ability to tweak components list
4) ability to save current entity state
a. at edit time to entity-asset file
b. to serialize current entity state at run-time
5) ability to tweak saved entity-asset file
6) ability to load entity-asset to ECS
7) ability to do the rest myself - i'd like to have an option to extend entity manager and entity debugger
8) +1 for [ChangedOnly]

 

1) After I tried ECS for some time, I think the best approach to group systems and setup order of systems is to make it able to set at Entity Debugger directly. The way to change the order of system can design it like Reorderable List Editor API that u can drag up and down to change the order.

2) Entity Debugger seems like not able to update enum data properly as it keeps the same value even the data has been changed. There are also a lot of data not able to visualize properly. I guess the feature is not completed yet.

3) It will be nice if EntityManager System at Entity Debugger has the same grouping same type components feature like other systems.

4) Able to record all the changes in Entity Debugger just like Profiler does so you are able to inspect all the changes has been made. I think it will even better if combine it with Profiler so u can inspect the changes of Entity Debugger with the data at Profiler together but it needs to figure out how to visualize the data.

 

After tried ECS for some time, I think make it both Game Object and Entity at Entity Debugger sync together seamlessly. Meaning that when u for example add a Damage ComponentData to the entity, u can see the data of Damage ComponentData at both Entity Debugger and Game Object inspector. Currently you only can sync the components attached at Game Object to entity at Entity Debugger.

From what I know, in future the current Game Object will be replaced to Entity but it will still support legacy Monobehaviour. I guess it will become something that I expect.

 

Information for the highlighted Entity is currently only displayed when the inspector panel is in "normal" mode.
Would be nice to have that info in debug mode too.

Also, it could be useful to be able to see the different instances/variations that exist for a given ISharedComponentData.

 

One important things to finding bugs is the order of system activation, how that plays out in a given frame.

Currently Profiler timeline mode is an excellent tool for that, but things could be more streamlined if you integrate that information with Entity Debugger. In Profiler the issue is that I have to zoom in very close to see all the system names, and slowly scrolls and click to check each system name from left to right. If we have a tab which list system activation order from top to bottom line by line in Entity Debugger that would be very useful.

 

How about color-coding the systems and entities with an attribute? naming certain archetypes or entities that have certain components and displaying entities by name?

 

Giving system names/labels and the ability to view it as a tree, would be nice to have.
Instead of having, PlayerThis, PlayerThat, BulletThis, BulletThat, we could for instance give them labels like Player/This, Player/That, Bullet/This, Bullet/That and the list would be displayed like the hierarchy editor.

 

Hello.

I just stumbled upon issue with Entity Debugger.
Shared Components exposed incorrectly in it.
Specifically they don't initialized with related value.

Here is example:

Code (CSharp):

1. public class ExampleSystem : JobComponentSystem {
2.     struct DataComponent : ISharedComponentData {
3.         public int id;
4.     }
5.     protected override void OnCreateManager(int capacity) {
6.         var entityManager = World.Active.GetOrCreateManager<EntityManager>();
7.         var entity        = entityManager.CreateEntity();
8.         entityManager.AddSharedComponentData(entity, new DataComponent{id = 13});
9.     }
10. }

Result: Value in Inspector did non match to actual.
Actual value of a component is fine, I checked this.


UPD: in thread, which I initially created, also noted that sometimes Component Data may be also displayed incorrectly.

 

I've been wondering what data is displayed/serialized in the Entity Debugger (I noticed it's a `ScriptableObject`, probably with a custom Editor on it) or if it would support `[System.Serializable]`.

I noticed that the `MonoBehaviour` I gave it doesn't display at all, making it a little harder to debug.