Відео

This is so awesome, fantastic work! Im really struggling with optimization for a game im making right now and i was so excited when watching this video, i was like "this is exactly what i need!". But alas the cost of not being able to use animation player is too much for me. The game is animation heavy so I would hate spending hours and hours writing animation shader code instead of the ease of animation player. If you can convert animation player to vertex shader that would really be a godsend

thank you 🙏

Finally I can make a 2d top down dynasty warriors

how did you make these animation??

can you make custom ID in godot like every goblin has his own Unick functions. goblin with ID = 0 can be super-fast goblin with ID= 1 can do magic and so on i did learn this one from construct 2 so i do wander if godot can do it too.

More of this please! Subbed!

Great phasing and tone, you're a really good presenter 💯

Man, you are getting a ton of totally unnecessary negativity in this comment section. You explained a lot of awesome content at a pace that was both engaging and digestible. I would bet that the people making negative comments are just projecting their insecurities. Don’t take them to heart, you’re making great content dude.

i guess this is useful to know, but its strange you dont ever mention the canvasgroup node, since it seems to be an easier way to do a similar thing, if not on a smaller scale (havent used it myself so im not sure how well it would work for larger scales, though i have some ideas i'd like to test sometime.

why is godot so slow? only 100,000 sprites drops you to 60fps??? really?

This might sound strange but, on 3D, in many specific circumstances, MeshInstance3D is more performant than MultiMeshInstance3D (as per 4.3). Using LODs, MeshInstance3Ds are able to reduce vertex count. MultiMeshInstance3D isn't able to use LODs properly a d hierarchical MultiMesh isn't a thing (dividing the MultiMesh in different LODs based on render distance). MeshInstance3D is able to use LODs per item, and the same mesh between many MeshInstance3D is still rendered in the same draw call (like MultiMeshInstance3D). I've done some experiments and, as on 4.3 there is no upside to using MultiMeshInstance3D if you are using LODs. Is more performant to use MeshInstance3D and LODs. But at the end of the day "try it yourselves, do your own experiments".

Hmmm, crispy cat...

0:05 Ok that "if true" in process function got me laughing real hard not gonna lie

open source is the best

So the y-sorting works for the instances itself when they move towards each other, but what with other objects from tilemaps or scene stuff? for example a sprite2d that is a tree, that is not managed by the multimesh. would the goblins go in front and behind the tree correctly depending on the trees pivot point with y-sorting on? also think about sharing source code when doing such videos.. it helps most people

Next make collision checks on all those goblins! 🎉

Bro i am your new subscriber 😊

So this doesn't work at all without explaining your custom multi-mesh-manager resource...whatever register_instance is, it does not work with the standard multi-mesh-instance-2d node

Bro i thought this would have like 800,000 views. Nice video, i subscribed!

Positive y points up in godot

This video was a pain to watch in 1x speed.

bro has an i9-14900k with the gtx 970. No need to flex like that

pro tip, you are better off using viewport texture instead of a vertex shader, or many of them even

Cool video The animations while you explain the topi are very smooth

this is great! I never noticed this node while checking the docs before. And the limitations actually seem more than manageable for simpler environmental objects like grass!

it's cool but we can't interact with them though...

To try everything Brilliant has to offer-free-for a full 30 days, visit brilliant.org/DeepDiveDev/ You’ll also get 20% off an annual premium subscription.

Thank you!

I was static typing variables already just because it felt like it made things more readable, but I was unaware of the performance boost, I'll keep this in mind.

Idk how godot does it's arrays but it might be better to also store a cap and and length variable and when pulling, just reduce the length and when adding, add to array using the length index unless the array is at its cap. The just use push and increase cap by 1. This will prevent a bunch of array copies and allocations

thank you for this video, i'm new to Godot so this video was very useful!

I've always used static typing, and GDScript was no exception when I started learning it. The difference honestly doesn't surprise me. Any time variants are used, you're adding extra processing time as the engine figures out what type of variable it's meant to be before engaging with it. C# variants get around this problem because they're not *actually* variants, they're strongly typed variables that inherit their type from their declaration (eg. var myVar = Object ). It's why you can only use them as locals.

As of 4.4 Jolt will be part of the engine, so no more downloading. You just need to switch it in the project settings

Thanks man, interesting. Coming from embedded C++, not declaring the variable types is confusing to me. I did not know it actually boost performance!

Great video, thanks 👍

I like your style man. Subbed.

good video! I also think pool can increase performance! But I think the GDScript is not a best option to create this! in Array you keep a pointer to the object, so object are not next to each other in memory which will not get the best performance! another think adding and removing object to array is performance costly sometimes for this you need to allocate memory which is the same thing as allocating memory for object! even if you want to remove from array it is better to remove the last element! by the way it is best this should be implemented in core or GDExtension

Thanks. Useful!

Best advice I can give for Godot devs, never listen to the people who make Godot. :)

This is the best explanation I've ever seen. It just makes sense!

very interesting subscribed

Keep in mind that measuring performance is not enough. Understand _why_ it is slow before making optimizations, like pooling. Vast majority of cases are because instantiation of objects take too long (like slow calculations during initialization, or too much allocation upfront when you don't need it). Limit what your objects needs to do when they are instantiated. Chances are you can get away with very minor changes that doesn't need to involve data structures like ring buffers, linked lists or some other arbitrary structure. See where you could pre-compute values, possibly store them as static values, and where your initializations could be deferred or lazily evaluated. It's often slower to tame memory by adding more abstractions, than for example just recalculating things If you know you're being limited by other factors, like garbage collector, before just picking the first tool that some comment tells you, try different ways (easiest first), and measure.

Keep grinding that content out - you deserve more followers and you will get them. Can't wait to watch your take on FSMs next!

I was running into performance issues in my godot project, and I implemented some of my own "scratch" fixes--- but this technique did help quite a bit when I did get around to trying it.

Nice video, though as others pointed out you most likely want to take objects out of the end of the pool rather than the start. I do want to "devil's advocate a little though, what Juan said was a little misleading I've seen people quote that tweet a bunch in the same context, so that's fair. But the example you showed really isn't what he was trying to address, I think he's responding to people wanting every single game object to be pooled in one or more pools regardless of how often they are added or removed from the game environment. The way he said it in that tweet can be interpreted any number of ways though, but imo it's not even presented as advice on optimization, just a random thought from Juan 6 years ago. For a more constructive critique, "Simple area2ds with sprites" are not that simple and not the best or simplest way to implement a large amount of bullets like that. That's 2 whole nodes in the tree and lots of functionality you will never need for those bullets. They are the easiest way to do it, yes, so if a simple pool of area/sprite bullets is good enough performance then go for it! The Godot docs specifically point out how the scene tree isn't always the best approach and show how to use the Server classes like the PhysicsServer and RenderingServer to manage actual lightweight instances (that live outside of GDScript comletely, other than a reference RID). There's also 2 different types of particle systems, which aren't as easy to use in collisions (you'll have to set up collision detecting manually) but are definitely an option and they handle the pooling for you plus have lots of nice options out of the box that could be useful for different kinds of firing patterns or bullet behaviors. Creating and destroying 3000+ objects a second is still always going to have a performance impact and if you need to go even further beyond that it will only get worse and worse, so pooling is the obvious approach for things like bullets in a shmup/bullet hell.

Why instantiate lot object when pool few object do trick? Glad you covered this, pooling can be very helpful. One thing you didn't explicitly mention, I think, is that pooling can move some initialization costs from hitting during runtime to a loading screen. So even if you only expect 1,000 instances of something in a level, spawning them all up front can give a performance boost. This can be helpful on mobile platforms where you don't get a lot of CPU time but you will probably have some leftover RAM. Not just in theory, this helped me and my team in a production environment once.

Looking at 6:44 I see a potential perf problem in your implementation: If the object pool is an Array, then remove_at(0) is probably a performance pitfall; remove_at(0) will have to copy all elements that come after it so it's an O(N) operation, using the Array as a stack instead (removing the last element instead of the first) should always be more performant O(1). This is the case even if you have a Queue instead, Queues can pop the first and the last element in O(1) time, but this is more expensive than popping the last element of an Array.

Remember, instantiating more object is a lot faster than getting an already instantiated object

I wonder how we could best re-educate Juan... But people in the Godot community do this a lot, where they throw out theoreticals but don't actually try it before they start talking. If you don't know if something will gain/lose performance, just try it and see. Theoreticals can only get you so far.

I did this automatically because when i originally tried the spawn and remove the player's attacks it would lag my game out each time the abilities were used, pooling worked a lot better for me