All language subtitles for 008 Object Pooling_en

OK, so let's take a look at a reasonably common situation where we can apply a design pattern that's

quite common to unity and game development in general, which is object pooling, it doesn't only relate

to game development, it can be used in browsers, for example, but we'll get to that in just a second.

So imagine that we have a very simple launcher on a behavior, and this is how it works.

It has a bullet prefab and an update.

If you hold down the space, then it goes ahead and creates a bullet.

So let's go into and see this in action.

We've got an object spawn object here, and you can see the object spawn has sorry, this is the wrong

objects --.

He wants to hide that object spawn.

In fact, what we want here is the object pool example, and in the object pool example, we've got

a launcher.

And in here you can see the launch script has a link to the bullet prefab, the bullet prefab here,

if we go and have a look at it, just has a bullet object as a Sprite renderer, and it has a speed

basically on this bullet.

Now we can go and have a look at the bullet speed and the bullet script just now.

So the bullet script has a very, very simple, configurable vector.

Three speed in updates updates its position using the speed and delta time.

When it becomes invisible, it destroys itself.

So the launch is responsible for instantiating it when we hit the spacebar, and it's responsible for

destroying itself when it becomes invisible.

This is a pretty common paradigm.

You may not necessarily do it this way.

You might do it based on the extent of the screen.

But the effect is that I hit spacebar.

The bullets appear on the screen and they clear themselves up.

So you can see here in the sample scene the bullet clones are getting created and then they're getting

destroyed again.

Now this is a little bit wasteful because as you can see here, we are creating and destroying continuously.

That's not really necessary.

Better would be to recycle these bullets when they go off screen instead of creating a new one.

We just use that bullet.

We move it back to the spawn point at the beginning of the gun or whatever else it is.

Now that would be the smart way.

How do we achieve this while using the object pull pattern?

So the situation we're currently in is we've got a client which is like gun.

It goes ahead and creates a new object over the course of doing its job when a space bar is hit, for

example.

And then at some point later down the line, we decide we don't need that object anymore.

Maybe it's the client doing this.

Maybe it's the object itself doesn't really matter because Hadden destroys the object.

Then later on, we go ahead and create yet another object and do the same process over and over again.

And initialization destruction is costly not just in unity, but in many, many situations.

You have to create a lot of memory, a lot of things, and that is fine when you got a small number

of objects.

The more and more projectiles you have, if you have a particularly projectile heavy game, this might

be more of a problem.

So the solution is to recycle, reduce, reuse and recycle.

So the way we're going to do that is by having some sort of intermediary object in between called an

object pool.

Now what happens is instead of the client creating and destroying objects itself directly, it's going

to ask the object pool to get it an object.

And if the object pool doesn't have any objects, it will go ahead and create one, and then it will

return that object to the client.

Now, if the client has finished with an object or if the object itself has finished with the object,

then it can go ahead and release it back to the object pool in question.

And that's going to go ahead and call something like disable on the object.

It's going to do something to disable that object.

And when the client goes to get again, the object pool has kept that object around.

It's kept it in.

It's deactivated pool and it will go ahead and simply enable the object and return the same object.

So now, instead of creating and destroying objects repeatedly, we're simply doing a much cheaper operation,

disabling and enabling those objects and keeping them around inside of an object pool.

Now, fortunately, in unity, we have a mechanism built in.

Now, basically, as of Unity 2021, we now have object pooling built right into unity, and it's pretty

cool how this works.

You can use this object, pool, object and interface.

They see that I object pool interface, which is implemented by the I object pool to you to create your

own object systems.

So how does this work?

Well, we would create a pool on the client, on whoever's using it.

In our case, it's the launcher and you would have to insert.

And shake that pool from something specific, so this is the not a great example.

I'm going to give you a better example.

Let's go into the code that we've got here.

Download it if you want to follow along.

So the client here is the launcher and it wants to be interacting with an object pool, as we saw in

our slides.

So the way we would do this is to add in a private variable here, which is going to be a type I object

pool.

And we have to say what it's a pool of, what's the type that's going to be in this pool?

It's going to be a bullet's pool.

So we'll call this the bullet pool and we need to instantiate this in a week.

So it's create an awake method here, and we do need to include using Unity Engine Pool in order to

get access to this.

Then we need to instantiate it to a concrete implementation of the I object pool interface.

So the way we do this is with something like object pool.

There are other types of pool here.

There's like a linked pool, there's a hash set pool that just have different mechanisms of storing

the objects under the hood.

I think the easiest for us to deal with at this particular point, and probably the one you're going

to use most often is just the object pool.

So let's just go with the object pool.

We're going to put in an object pool with the bullets type there again, and then we have a bunch of

arguments that we need to pass in here.

So let's have a look at what it will complain about.

Well, the first thing I'm doing wrong is I need to use the new keyword.

And then if I hover over the constructor that we're using, you can see the different functions that

this takes.

It takes a create function it takes and this is not the easiest place to see it.

So let's go over to the documentation and see what it takes.

We go down to the section in the documentation about the object pool itself.

And don't worry, these links will be in the resources for you to have a look at, and you can see that

these are the parameters to the object pool constructor.

We have a create function, so this is what gets called when we need to create a new instance in the

pool.

If there wasn't already an instance already, as we saw in that diagram, we have an action on get.

So this happens every time an object is got from the pool, so that would be enabling would happen.

Like that action release?

So when we return something back to the pool handle it, does it get disabled so that it's, you know,

isn't affecting gameplay or whatever?

Basically, this is something that can happen whenever we like.

And then we've got the action on destroy.

So this is if it gets returned to the pool and there's too many items in the pool, it and the pool

is configured to have fewer items.

As you can see, there are there are properties further down here for configuring the capacity of the

pool because it sends the pool pools to full and we want to destroy it.

Then this tells it how it can destroy an object in the pool.

So this is all configured through passing in functions to the constructor, which will see how to do

in just a second.

So the first thing we want to pass in is a create function.

So we're going to have I'm going to call it, create bullet like so again, because we're passing in

the function itself and we don't want to be called now.

We want it to be called at a later date, then we don't want to put the parentheses on the end.

Now can you use control dot to generate a method and you'll see that it will go ahead and give it the

correct signature here, which is that it should return the type of bullet it should return a bullet

for us to use.

So how do we instantiate a bullet?

Well, we've got our bullet prefab here so you can go ahead and just use this instantiate call from

Line twenty one.

So I'm just going to cut it out there and I'm going to paste in the instantiate bullet prefab like so

so that's going to go ahead and create a bullet prefab, and we want to make sure that we return that

bullet prefab like so.

And now how do we go ahead?

And instead of an update instantiating we need to be getting an object from the pool so that it has

the opportunity to reuse from that pool if it wants to.

So the way we do this is to do bullet pool dot get instead of having what we were doing previously,

basically instead of having it instantiate directly.

So this now should have the opportunity to reuse if objects are being properly returned to the pool.

But at the moment they are not.

They're just simply being destroyed by the bullet.

So what happens here is that we need our bullet to have a reference to the pool in order to release

itself.

So the way we're going to do this is to have a.

Private variable on the bullet, which references the pool, so it's going to be I object pool and it's

going to be a type bullet, and we'll call this the bullet pool again.

And we need to have the using statements using Unity Engine Pool for this to work, we're also going

to have a public method here, which I'm just going to call void set pool.

And it's going to take in an I object pool and we're going to use this as setter as you might imagine

going to set the pool from that parameter.

Now that means that's in on became visible instead of destroying the current game object.

What we're going to do is we're going to return it to the pool so we can do bullet pool dot release

and we can pass in our selves because it takes a bullet.

We can pass it ourselves to release ourselves when we become invisible.

Now, the final step of the puzzle is to make that link between the bullet and the pool that it's part

of, so we can do that and launcher in launcher, we instantiate this bullet prefab.

Now, once we've got hold of that, let's just introduce a little local bullet variable by doing a controlled

alternate, factoring into a variable.

Then once we've got a bullet before we return it, we want to give it a link to the pool.

So it's going to be bullet dot set pool and the pool we're passing in is the bullet pool that we instantiate

in a week.

So hopefully you're following along.

What we've got here is a bullet pool owned by the launcher, created by the launcher.

It will automatically create bullets using this create bullet function that we have created here in

the launcher.

It gives the bullet a link to the pool that it's dealing with.

And now, instead of dealing with instantiating and destruction directly, we allow the pool to do that

and we interface with the pool to get and release objects into it.

So let's go ahead and see if this alleviates some of the issue we were having previously.

So if we go back to unity and hit play and then we have a look.

And what's the behavior if I go ahead and spawn a bullet?

You can see once it's gone off screen, it does not disappear from our scene.

Hierarchy isn't being destroyed, it's being returned to the pool.

However, it's not being disabled.

And also, when I hit space, you can see it's not being reset to be at the starting location where

it should be fired from.

That's something that should happen.

Every time we get a bullet from the pool, its location should be reset and it should be enabled.

So those are two things that I would like to challenge you to do.

The way we're going to do this is by passing in a couple more parameters here to create two object pool

and we create it.

So here, as well as create bullets, we're going to have an on get.

And let's have also an on release method and these two methods we're going to go ahead and implement.

It's going to be controlled darts to generate the method on launcher and the same again for on release.

So now we've got on get on release.

I'm just going to reorder these into the order that makes the most sense.

So again, create bullet on, get and then release being the final thing in the lifecycle and what I

would like you to do as your challenge.

No challenge slide here is implement on get.

So they re enables a deactivated bullet and it also updates its location to be at the starting point

of the launcher and on release should disable the bullet so it's no longer visible.

Pause the video and have a go.

OK.

Welcome back, so hopefully you've had a little play around in this.

So the first thing to do with on let's try with on release, actually, how are we going to disable

the bullet?

Well, I don't want to just disable the bullet.

I actually want to disable its entire game object.

So I'll do objects, which is in this case, is the bullet.

So let's rename that straight away to bullet, which I think is a better name for this parameter.

Then we're going to do Bullet Dot Game Object Dot set active false.

So that disables the game object on which the bullet is a script now on Get is going to do the opposite

of this.

So the parameter again, I'm going to rename two bullets, then I'm going into a bullet game object

set active, equal to true.

So now all the scripts in that bullet are going to run.

But like I said, the other thing we need to do here is set the transform of the bullets or rather its

position.

So bullet transformed opposition is equal to the launchers transformed opposition.

This is something we weren't actually doing initially, so this may update the location of our launch.

Let's check where our launches.

It's down here at the bottom.

So I'm going to put it over on the left hand side of the screen, give our bullet a little bit more

travel time across the screen as well.

Now I've got an error somewhere in my code.

I got an extra comma here in this list of methods that I'm passing into an object pool constructor.

So let's remove that.

And now it should hopefully compile.

And once it does, let's go ahead and hit play and start spawning some bullets.

So we spawn all these bullets.

They start to go off the screen and you can see as they go off screen, the bullets in the hierarchy

are being disabled.

So that's the release process happening.

The bullets get disabled when they are released.

Now what happens if I spawn some new bullets?

Well, actually, no new bullets get spawn, but those bullets that went back into the object pool got

re-enabled and reset to the previous location, so you can see that it spawns as many bullets as it

needs.

But then, once those are spawned, it no longer needs them.

It goes ahead and disables them.

Now, one more thing that you can do with this object pool that was some other stuff in here, and one

of them was the max size.

Now that's just an interesting parameter for us to set.

By the way, you can set one of these parameters by name just like us.

So.

So I can do max size to be, let's say, three, for example.

And let's put a comma on the last line, the app that already works.

So that saying, set the parameter maxes to three.

What's that going to do?

Let's go ahead and try this out.

So let's restart, play and spawn some bullets so you can see I can spawn as many bullets as I want.

That's not what max size is doing.

However, let's let the steady state just die down.

Well, nothing here has particularly happened.

So why is that?

That's because we haven't given it away to destroy bullets.

So we need an on destroy call back to pass into our constructor.

We can go ahead and generate that method in launcher, and this is going to be pretty straightforward.

How do we go ahead and destroy a bullet while we do it by destroying its game object?

So let's rename the parameter again as familiar to Bullet.

And we're also going to call the destroy method on bullets dots game object, so that should destroy

a bullet.

Now, if we head back into unity and start spawning some of these, then you can see that when it gets

destroyed, some of them actually do get destroyed and you can see that what's left is only three bullets,

because that is the max size of the object pool.

So what happens is with an object pool, if you configure a max size, then it will trim back the object

pool when objects are released and some of them will get destroyed if the pool is already over that

size.

So you can see we're only ever left with a pool of three bullets in this particular configuration,

although it will create more bullets if needed at any given point in time.

Now, why might you do this?

You might do this for resource saving purposes, because if you spawn loads and loads of bullets and

you keep them around all the time, then that is increasing the amount of memory your game uses and

the amount of resources even though they are disabled.

So that is the object pooling pattern and now easier than ever to implement in unity, thanks to native

support for this object pool interface.