 follow camera working. Let's identify some of the issues that we were talking about in the previous video and look at how we can visualize those issues and talk about some of the ways in which we can resolve those particular issues. Okay, so let's jump over into Unity and get started. Okay, so let's take a look at a couple other ways we can smooth out the camera and not use the Vector3.Lirp. Vector3.Lirp is great, but it does have some problems when you're dealing with cameras like this. Okay, so what we want to do is we first want to just visualize what the problem is, and I like to do that with the debug.drawray method. So let's go back over here into MonoDevelop and what I want to do is I want to visualize the distance behind the character and it's the character's forward. So let's first get a debug.drawray and what I want to do is draw a ray from the target's position to the target's forward but negative so we get the back direction. And we're going to color that one red. Okay, and then I want to do another debug.drawray. All right, and what I need to do, actually before we do that, what I need to do is I need to smooth out another vector. Okay, so let's just do a private Vector3 debug distance. How about that? And for this, what I'm going to do is say that debug distance is equal to Vector3.Lirp. Okay, and it's going to be debug distance and we want to do the, whoops, sorry, it's debug distance. That shouldn't have done that. So target.forward so we get the back and we'll color this one .green. Okay, so let's actually then debug.drawray that particular vector. Sorry, I just made a total mistake there. So this is the Lirp. So I want to do a time .deltaTime times the M smooth speed that we're currently using. Okay, and then we want to do the color for that. So we're going to color this one green and we want to go from the target position to this new debug distance. All right, there we go, we made it through. Okay, so let's take a look at that and you'll see right off the bat when I hit play what the actual issue is as we rotate the character around. All right, so now we have our two vectors here. And if I turn off the ground, this will be a lot easier to see here. So what I'm going to do is I'm going to start to rotate this. And you'll notice that the green line, the ray, isn't maintaining its distance. All right, it's just trying to catch up to the position and it's finding the shortest path to that end position or to that target position, which is at the end of the red ray or red line. Okay, and we want to solve that. So one way we can solve that right off the bat is to do a Slurp. All right, so and that's vector three dot Slurp. There we go. All right, so if we were to actually check out the documentation on this, you notice that it's spherically interpolates between two vectors. Now this right off the bat sounds like it should work for us. But let's take a look and see what that does. Okay, so let me turn off the ground again so we can see our rays that we're drawing. Okay, and there you go. Actually, we are maintaining that distance. Uh-oh, but you'll notice now we're getting some weird errors. And if we actually were to look at it, it is actually growing, but it is maintaining that distance pretty well. So it's a it's a better solution than actually using the LURP in this case for this particular situation. All right, so then let's take a look at one more before we close out this. So I'm going to do a smooth damp. So vector three dot smooth damp. Now for this, I do actually need another variable. So I need a public or a private vector three. I'm just going to call this a ref velocity. Okay, so if we were to actually check out the documentation for this, you'll notice that, whoops, let's do the vector three dot smooth damp. That we need to provide a ref variable because it's going to output the velocity into this particular ref variable. So that's why we create this extra variable for this. And in here what we want to do is say ref ref velocity. And then we don't need the time to delta time because this just uses a value, a certain amount of time that it needs to catch up to that particular position, the debug distance or the forward sorry. Okay, so let's jump back into unity here and let's check this out. Okay, so you notice how slow it's taken to get to that position. So what we need to do, this is the opposite of the lerp or the slurp, we need to do something like point two. And now it'll maintain its speed, but you'll notice that we're getting that same problem. It's just taking a linear path or shortest path to its target. So that's not going to work for us either. All right. So that's really all I wanted to do in this video is just cover the other options that we have for smoothing out values, especially these vectors and floats. So in the next video, we're going to take a look at how to properly make sure that the camera is always maintaining its distance behind the character while still smoothing out the camera motion. Okay. Thanks so much.