I’ve been doing some work on the AI for enemy behaviours for an unreleased game Endless Elevator and have been delving into the book “Unity 2018 Artificial Intelligence Cookbook – Second Edition” by Jorge Palacios.

It uses the **Normalize()** function regularly to record the direction of an object in relation to another object and it got me thinking about the usefulness of this function. You can see why something like knowing the direction of the Player could be good for an enemy AI behaviour but I wanted to investigate more deeply about how this worked and how I could use it.

One of the things I hadn’t consciously been aware of, but is obvious once you point it out, is that a **Vector3** can define a **location** (ie. a point in space 0, 0, 0) but it can also define a **direction** if you have a starting position and a target position.

A good example of a Vector being used to denote a location and a direction in Unity is the **Ray**.

The Ray consists of two Vector3 data points. The first Vector3 is the source position the ray is taken from and the second Vector3 is the direction of the target.

When a direction Vector3 is Normalized it keeps it’s direction but it’s length (how far away one object is from another) is set to a point between 0 and 1. In Unity they round down to 0 if the objects are very close to each other (anything under about 0.04f of a unit) anything above that gets Normalized up to 1.

As an **example** we can simplify a bit by limiting ourselves to a Vector2.

A Vector2 can also be either a point or a direction depending on what you want to use it for.

If it’s (3, 0) then it could be either a point at x=3, y=0, or a direction along the x axis (one dimension) with a length of 3 and a slope of 0.

If you Normalize() that example the Vector2 becomes (1, 0). It will have a length of 1 but still be pointing in the x direction.

If you add the y value (dimension) into the picture where x=3, y=3 the Normalized value becomes (0.7, 0.7). So without going into the maths of why … you can see that the axis/dimensions impact on each other to define the Normalized direction.

We can extrapolate this into three dimensions without too much difficulty but I’m not going to describe that here as it’s not that necessary to understand. We only need to grasp what this means and what sort of use you can make of it in a Unity project.

**For Example…**

This is a simple use case of why you might want to use Normalize().

(Note that there is also a Normalized() function where the current vector is left unchanged and a new normalized vector is returned).

I’ve created an example project where the relationship between two objects (a Cube and a Sphere) will give us a direction (using Normalize()). The direction is applied to a transform.Translate function on a third object (a Cylinder) which now moves in the given direction.

In this script below attached to our Green Cube (the unchanging point of origin – 0, 0, 0) we define the Pink Sphere as the target. In the script we get the difference between the position of the sphere and the Cube and Normalize() it to make a direction. It doesn’t matter how far the Sphere is from the Cube the direction stays the same.

Also to extend the example I’ve added a Ray with the same origin as the Cube (0, 0, 0) that will always point to the Sphere. This shows that the Normalized Vector3 is the same as the direction of the Ray pointing to the Sphere.

**Normalizing Direction**

The *public Vector3 lineDirection* is the difference between the position of the Cube and the Sphere. This is the variable we will pass to the Cylinder to move it in the required direction.

```
using UnityEngine;
using UnityEngine.UI;
public class HowToNormalizeDirection : MonoBehaviour {
public Vector3 lineDirection;
public GameObject target;
public Text vector_text;
public Text norm_text;
public Text ray_direction;
public Ray whatsTheRay;
// Use this for initialization
void Start () {
lineDirection = new Vector3();
whatsTheRay = new Ray();
}
// Update is called once per frame
void Update () {
lineDirection = target.transform.position - transform.position;
vector_text.text = "Vector3 target.transform.position :" + lineDirection;
lineDirection.Normalize();
norm_text.text = "Vector3 Normalized() :" + lineDirection;
whatsTheRay = new Ray(transform.position, target.transform.position);
ray_direction.text = "Ray : " + whatsTheRay.ToString();
}
}
```

**Moving the Capsule in the Same Direction**

In this script below attached to the Cylinder we get the direction from the *lineDirection* variable above but we could also have used the inbuilt *Ray.direction* function to return the same result.

```
using UnityEngine;
public class MoveCapsule : MonoBehaviour {
public Vector3 direction;
public float speed;
// Use this for initialization
void Start () {
direction = Vector3.zero;
speed = 0.50f;
}
// Update is called once per frame
void Update () {
var script = GameObject.FindWithTag("Cube").GetComponent();
direction = script.lineDirection;
//direction = script.whatsTheRay.direction;
transform.Translate(direction * speed * Time.deltaTime);
}
}
```

In the **Video **below you can see this demonstrated. The position of the Pink Sphere is being manually manipulated using the Transform on the right. The text areas expose the vector3 values being accessed by the objects and scripts.

So what’s going on in this video amateur hour?

The three lines of text at the top of the game scene represent:

1. The Vector3 Position of the Pink Sphere.

2. The Vector3 Normalized direction which is the relationship between the position of the Green Cube (0, 0, 0) and the Pink Sphere (x, y, z).

3. The uses of Vector3 in the Ray. First the position of the origin and then the Direction of the Ray which is exactly analogous to the Normalized Vector3 in point 2 above.

The uses for something like this could extend to a weapon aiming system, a custom controller or be passed into a path finding routine. This is not the only option of course there are other built in methods like transform.LookAt(target) available which may accomplish your programming goal.

During the research for this post I found the following links helpful.

https://docs.unity3d.com/ScriptReference/Vector3.Normalize.html

https://docs.unity3d.com/ScriptReference/Vector3-normalized.html (which is a different but related function)

https://forum.unity.com/threads/what-is-vector3-normalize.164135/

https://answers.unity.com/questions/52881/vector-normalization-question.html

https://www.dummies.com/education/math/calculus/finding-the-unit-vector-of-a-vector/ (for why you really don’t want to know about the math or do it by hand)

https://www.mathsisfun.com/algebra/vector-unit.html (best for simple vector explanation)

https://docs.unity3d.com/ScriptReference/Ray.html

https://docs.unity3d.com/ScriptReference/Ray-ctor.html