Vector2 Archives - Selfloop

Understanding “Vector” in Unity

By | Unity3D | No Comments

Definition:  In unity, Vector is the data type where you can do all types of vector calculation (Dot product, Cross product, Normalize, Projection, Magnitude) and other unity given function such as “Distance” & “MoveTowards” etc. As the “Distance” and “MoveTowards” are highly used in our “Game Development” process. We will try to describe as much as possible down below.


  • Distance: It calculate the distance between 2 vector point. We usually use it for detection or creating a sensor like a game object will react when the user comes to a certain point.

Parameter:         Vector2.Distance(Vector2.position, Vector2.position)

Vector3.Distance(Vector3.position, Vector3.position).


Vector (1)

Here, the “Mine” will be explode when the distance between the “Player” & “Mine” will be less than or equal to “3.14”. As the “Player” is at “5.14” distance, so the “Mine” is not exploding. We can see the following script for more detail.

  • MoveTowards: It basically moves the current position of the game object to the targeted position based on the velocity that has been assigned in the “MoveTowards” function parameter.


Vector2.MoveTowards(Vector2.position (Current), Vector2.position (Target), Velocity).

Vector3.MoveTowards(Vector3.position (Current), Vector3.position (Target), Velocity).


Problem: Let us consider that we have a homing missile that chases the player. If the player is within its range, It will start chasing the player. Let’s see the following script reference.



# The reference of the documents are taken from the “Unity – Documentation”.

Muhammad Tashfiqul Bari

Mentor at Coursera

Understanding : Transform, position, scale, rotate (Unity)

By | Unity3D | No Comments

Definition: Almost all the “GameObject” has a “Transform” component as its responsible to denote the position, rotation and scaling in the game world, where these values can be changed in 3 different axis (x, y, z).

Let’s break down each part for our own better understanding and see the usage of the “variables” & “function” that are mostly used from the “Transform” component.

  • transform: when we write “transform” in our script, it takes the reference of the “Transform” component that is attached with the “GameObject”. Let’s see the picture,


Here, the “Stick Man” game object has transform component which we can see in the “Inspector” view. When we write “transform” in our script, it asks the game object to pass him the reference of its own “Transform” component. So any change that you make with the “transform” in your script, it will make the change of “Transform” component of the “GameObject” (Stick Man) in the game world.

  • position: It is used to get/set the position of the “GameObject”. The “transform.position” takes “Vector3” as the argument. So now the question might be come, what is “Vector3”? Well, “Vector3” is the set of 3 variables, who represent the 3D vectors & points in the game world. Let’s see the picture below,


Here we can see the “Vector3” representation of the “Stick Man” “GameObject in the game world. So if we write “Debug.Log(transform.position);” in our script, we could see “(2,2,0)” as our output in the Unity Log.


But what if we want to change the position through the script, isn’t there anyway to do that? Yes, there are. If we would like to change the position through our script, we can use any of the following 2 ways to change the position.

position = new Vector3(5,4,3);

Vector3 ourNewPosition = new Vector3(5,4,3);

transform.position = ourNewPosition;

localPosition: It is used to get/set localPosition of the “GameObject” respect to its parent. Let’s see the following figure.


As we can see, the “transform.position” is showing the position of the “Hat” respect to the axis of the game world, where the “transform.localPosition” is showing the position of the “Hat” respect to “Stick Man” position as it’s the child of the “Stick Man” game object.

  • eulerAngles: It represent the rotation of the “GameObject” with respect to X/Y/Z axis in degrees. The “eulerAngles” take the argument as Vector3, where the X-represent the degrees around the X-Axis, Y-represent the degree around the Y-Axis and Z-represent the degree around the Z-Axis. I usually use “eulerAngle” when I want to read the rotation in degree around the Axis in world space. To simply read the rotation type,




Which will show rotation in degrees of the gameObject where the script has been attached.

  • Rotate: This function is responsible for rotating the gameObject over the x, y & z axis. “transform.Rotate” takes “Vector3” as the argument. So if someone write down “transform.Rotate(0,0,1)”, it means there is “1” degree of rotation over the Z-axis. One of the best practice I use to declare a “rotationSpeed” from the inspector, then by using
  • Vector2.left: (-1,0,0),
  • Vector2.right: (1,0,0),
  • Vector2.up: (0,1,0),
  • Vector2.down: (0,-1,0),
  • Vector2.forward: (0,0,1),
  • Vector2.back: (0,0,-1),

I decide which direction the gameObject will be rotate. So by simple typing down these to my script,

public float rotationSpeed;

                void Update(){ 

                transform.Rotate(Vector3.forward * rotationSpeed);


It will simply rotate the gameObject over the positive Z-axis with the declared rotation speed that has been assign in inspector.

Note: Like the “transform.localPosition” , we also have the “transform.localEulerAngle” for get/set the rotation respect to its parent. Let’s see some of the figure about the rotation in the given below.

Rotation X-AxisRotation Y-AxisRotation Z-Axis

  • transform.scale: It represent the scaling of the gameObject over the X,Y & Z axis. “transform.scale” also takes argument of “Vector3” where the “Vector3.x” represent scaling over the X-Axis, “Vector3.y” represent scaling over the Y-Axis & “Vector3.z” represent scaling over the Z-Axis.

So for example, if we want to scale a game object 50% over X-axis, then all we have to do is to write (we are considering the current scale as (1,1,1). )

transform.scale = new Vector(1.5,1,1);

  • localScale: It is used to get/set localScale of the “GameObject” respect to its parent. Let’s see the following figure.

Scaling X-AxisScaling Y-AxisScaling Z-Axis

# The reference of the documents are taken from the “Unity – Documentation”.