Відео

Aghh thank you :)

Honestly, as the game scales, that might be an approach I'll have to consider. I still need to iterate each group so as the amount of systems grows, the current implementation becomes more and more of a bottleneck. I think needing to iterate each system once on entity creation sounds better than having to iterate each group for every system.

@@cient_dev ofc. we need to keep in mind that any component removal / addition to the entity would also trigger an interactions to the system so also you would need to keep in mind the house keeping of where the entities are

Cascadia Code :)

Good catch!!

Thank you! From a code perspective: It's all available in the description! But for performance, every time I add/remove a component, the entity is sorted into a sparse set that groups entities with similar components, and the for each just iterates and returns each of the entity's components in the relevant groups as a parameter in the ForEach function (Went more indepth about some decisions in the last video). It's flexible but definitely still a lot of room for improvement though!

that's very interesting, thank you for the insights!

This is in my own engine which uses a fixed timestep on physics; so I pass in the fixed timestep as deltatime. Maybe it would be better for me to rename it to fixedDeltaTime for clarity

I had heard it was your own engine, but since most engines implement standard DT and fixed DT, a lot of bugs can be generated by using the incorrect one If there is a possibility of you wanting a non-fixed dt in the future, future you may appreciate the clarification 👍

It's called Github Dark, part of the Github themes extension on Visual Studio :)

Thank you! :.)

Next video is all about suffering!

@@cient_dev what’s a good coding session without sweat and tears am I right!

0:31 WHAT WORDPRESS IS A GAME ENGINE?!?!!?! LOL

@@99u99 Anything is a game engine if you're brave enough

. How would you get a job in the future , from self thought

You publish projects and get the attention of recruiters ​@@ontheotherhand463

I just did this for my version of a sparse set ecs in odin. Works great, saves minimal time when working with 10,000,000 entities but still, it does improve the performance.

​@IogaMaster That's good to hear. I'm used to minimal hardware which often don't even have floating point support. I think modern processors don't mind division and modulus too much, compared to some of the lower end microcontrollers. If the bulk of the work is not in indexing data, then access times will likely not improve performance more than optimizing the bulk work. For simpler tasks, I'd imagine you may gain a significant speedup.

what do you mean exactly?

@@lavatasche2806 well. It would be simpler code not to have to handle the concept of an entity. So I figured it might translate into faster code in general too? Chaching is about the right order but also about memory size. And preparing memory also gets slower the more extra you have to do. I have not tested yet anything myself though. I was just wondering. I am just about to finish the plugin system's handling of "editor" plugins so that the PNS kernel does not load editor nodes/systems if it is in runtime mode. And that of course the kernel tracks what even belongs to the plugin in the first place. Bevy can not do auto registering of types fully either. My kernel can because it does not use type unsafe handles like entity handles. Bevy seem not to have component handles either. So disclaimer is that I am in general anti entity/components and use nodes instead. A node handle is obviously type save. That allows me to scan an entire hierarchy of such nodes. Whether that extra info could translate into more performance ontop of the full auto type registering that I do not known yet. In the end of course it is the systems that require the access so determine the access pattern. Mind though that regarding optimized access Bevy and my kernel may run faster because we got a systems executor. Some ECS do not. Any system in the same "algorithmic" order can be executed within in that algorithmic order in a different system order depending on what data it accessed. My point is just that for the record that ECS kernels without a system executor are not a thing. It is not only about how you store the data but how you access it. Bevy seems to allow this pure fetching nonsense too. No to mention that the entire idea of flexibility of an ECS (or in my case PNS so Prefabs Nodes Systems) is also compromised in non system executing kernels because systems are also entry points for plugins. Bevy though does not force plugin use either. Bevy also for some silly reason requires like 5 extra crates just to use the ECS kernel without the Bevy engine. That is why I started my own PNS kernel. The entity/components part was not even the first problem. Godot's engine also uses a nodes based kernel. Though it seems it uses ECS too when handling mass processing. Problem with ECS is that it is making thinks more flat then they actually are by allowing type unsafe handles like entity handles. Instead of spaghetti code you get lasange code. Bottom line is that my PNS vs ECS war may end in a draw. I was initially afraid that ECS may be much faster then PNS. But the goal of my PNS kernel never was to become a speed demon but be ergonomic. That is why unlike Bevy it only needs one crate instead of 5. And forces systems and plugins. And also has a runtime/edittime mode for plugins plus compile time definition of configs/assets/scene/savegame serialization instead of a runtime like in Bevy and likely any other kernel. Seems I can also remove the "query" type bloat from the system signature. I still do not understand why that is in Bevy in the first place. It flies into the face of ECS kernels that have a system executor and do have the querying under the hood. Anyways... sorry for the text wall. :/

@techpriest4787 yes the rambling is unecessary. I read your whole wall of text and still have no idea what you are talking about. What exactly do you mean by nodes? Are you talking about nodes similiarly to godot? What is the difference between nodes and components other then that nodes are in a tree structure. You still need the concept of an entity in a node based system? Nodes are very much not known for their efficiency and that is why I am confused

@@lavatasche2806 nodes are essentially components just without the entities. I guess it is the misconception that they are locked into a hierarchy. But they are not. ECS is just doing a different kind of access. That is why it is able to break out of the hierarchy and do things in parallel and also have an awareness in parallel what the types are so be able to control execution/ access order so do cache optimization. By using a fetch or query so find them not via handles but by type and that from a centralized storage. My PNS kernel does the same with nodes. One also can not break out of hierarchy to 100% in an ECS either. There is obviously a limit to how parallel a code can be. And that is all ECS really does frankly. That is why even an ECS does use handles. Bevy uses entity handles that are not type save because entities are not types. So ECS also requires hierarchy like access but in an inferior way. Perhaps not from a performance point of view compared to PNS nor do I think at this point that it has an advantage either. But from a clean code point of view obviously it is lacking. Leading to other difficulties of not being able to auto register data at startup because it lacks hierarchy information because of lack of type information from the hierarchy side in the first place. The handles obviously reintroduce the concept of a hierarchy again. If I am not mistaken then unlike Bevy the Flecs kernel actually provides handles for components!? Either way. Maybe I am just too dense because I am still sort of new to this. But I just fail to see the point of entities. I only understand the merit of "systems".

@@techpriest4787 entities are needed to associate the components with something. How would you differentiate two enemies with different components for example?

It's what I know and does what I want; I don't really have a reason to justify the time it takes to learn Vulkan or DX :P

@@cient_dev well, we’re in the same boat then :) One thing that might tips me over is that OpenGL error message is so bad, it never tells you wth went wrong beside an enum and sometimes the doc page doesn’t even include the actual reason why it failed, D3D is better at that.

Thank you!! This stuff in particular was just the result of looking up multiple articles about ECS and stumbling across the term 'sparse set' multiple times. From a more general sense, I started by learning C++ and getting comfortable with it, then I learned OpenGL for graphics/rendering, then after that, it's just a matter of practise/delving into any topics you come across that seem interesting. Here's some notable resources I used myself to learn: C++: www.learncpp.com/ + TheCherno on UA-cam OpenGL: learnopengl.com/ + Lots and lots of extra learning via videos/articles Game dev: Game programming patterns by Robert Nystrom Only go into this stuff if you really really want to learn it, I'd highly recommend saving the time and learning an existing engine; I just find the engine development stuff more fun. Good luck!

His voice is very similar, in a good way

My favourite song on the portal OST :.)

Maybe! It's hard to tell, plus the linked list should be packed in memory to take advantage of the cache. Then again, you can forget the cache and implement what makes sense for you! ECS is still somewhat young and has many avenues, and I don't think what i have here is a top contender for one, but the simplicity + reduced memory overhead is enough for me Let me know your findings though if you explore this route!

Yep, we need to first get the bit position via map, then we use that bit position as an index into a vector holding the different component list. Maybe you can just make each entity hold a map that contains a key as the component name and a pointer to the component pool as a value so you only have 1 layer of indirection (as I had in my old implementation) but that's expensive (each entity needs a map now instead of just a bitset) and across millions of entities it only gets amplified. Comparing this to my old 1 layer of indirection implementation but more expensive keys/map, I found this to be a lot faster with benchmarks

also combine pagination and map ? but rather than using std::map for saving on page allocations, u can write a custom simple map basically create a vector of index -> index mapping, which maps the required page index to the actual sparse page index, this would avoid the many heap allocations and lookups would be faster than std::map the only downside to this is that the memory usage maybe slightly higher than the map approch

The problem with using array is that it preallocates all of its elements, so if we have two very spaced out pages, everything inbetween would be allocated if we used array, and be a memory issue, despite avoiding allocations/being faster on average

@@cient_dev no no, I meant a vector of arrays rather than a vector of vectors where each array is a page then use a map to only allocate pages that are in use rather than using std map, we create a custom vector based map, this does use a little bit extra storage (array of "virtual page index -> real page index" but if the page size is large (like 1000, that you suggested in the video) this vector map would not be that big so tldr 2 vectors vector<array<uint32_t>> // all the allocated pages vector<uint32_t> // sudo map that maps virutal page index to the real page index in the above vector

if you have a discord server, I can share my impl to better explain what I mean 😅, if not all good, great work tho :D