Transform class

Transform

• Script Reference: Transform
• Manual: Transform
• Important classes: Transform
• The GameObject's position, rotation and scale can be manipulated via its Transform component
  • either by using the included methods, or by directly manipulating properties
  • Properties are either global or local: e.g., position vs localPosition
  • Local coordinates are with respect to the GameObject's parent

Translation

• Translation properties (can be directly changed):
  • transform.position
  • transform.localPosition
• Translation (movement) methods:
  • transform.Translate()

    float moveSpeed = 3.0f;
    if(Input.GetKey(KeyCode.UpArrow))
      transform.Translate(Vector3.forward * moveSpeed * Time.deltaTime);
    
    if(Input.GetKey(KeyCode.DownArrow))
      transform.Translate(-Vector3.forward * moveSpeed * Time.deltaTime);
    

  • Note: Translating happens by default according to GameObject's local coordinate system

Rotation

• Manual: Rotation and orientation in Unity
• The rotation of a transform visible in the inspector is shown as Euler angles
  • Secretly, Unity uses Quaternions to store the rotation of a transform
  • Both are available in code
• Rotation properties:
  • transform.rotation, global rotation as a Quaternion
  • transform.localRotation, local rotation as a Quaternion
  • transform.eulerAngles, global rotation as Euler angles (Vector3)
  • transform.localEulerAngles, local rotation as Euler angles (Vector3)

• Rotation methods:

  • transform.RotateAround()

  • transform.LookAt()

  • transform.Rotate() (multiple variants available)

    if(Input.GetKey(KeyCode.LeftArrow))
      transform.Rotate(Vector3.up, -turnSpeed * Time.deltaTime);
    
    if(Input.GetKey(KeyCode.RightArrow))
      transform.Rotate(Vector3.up, turnSpeed * Time.deltaTime);
    

Scale

• There are no methods for changing scale.
• Scale properties:
  • transform.localScale
    • Script Reference: localScale
  • transform.lossyScale
    • Read-only!
    • Script Reference: lossyScale

Local axes

• transform.up, transform.right and transform.forward refer to the local axes of the GameObject: green, red and blue, respectively
  • Global versions are Vector3.up, Vector3.right and Vector3.forward
• You can use them to e.g., rotate the GameObject around these axes:

  if (Input.GetKey(KeyCode.LeftAlt))
      transform.RotateAround(
          transform.position,  // rotates along the GameObject's origin point...
          transform.right,     // around the GameObject's red axis... 
          180 * Time.deltaTime // with a rate of 180 degrees per second.
      );  
  

Exercise 1.

Make a child GameObject rotate around its parent.

Extra: How to rotate something by x degrees

• In a mishmash of vectors, rotations and transforms, it can be difficult to see what to do when trying to apply rotations!
  • Let's say, we want to rotate something around the global axis by .
• First, create a new rotation with Quaternion.Euler:

  Quaternion newRotation = Quaternion.Euler(0, 0, 30);
  

• Then, we use it to rotate whatever we need to rotate...

• To rotate a Vector3 by a Quaternion:

  Vector3 newVector = newRotation * oldVector; 
  

• To rotate a Quaternion by a Quaternion:

  Quaternion newQuaternion = newRotation * oldQuaternion;
  

  • We can use this technique to rotate a Transform by a Quaternion:

    transform.rotation = newRotation * transform.rotation;
    

• Note: We do not need a Quaternion to rotate a transform. We can just apply the rotation with

  transform.Rotate(0, 0, 30);
  

Extra: How to look instantly towards a point (3D)

• What if we don't know how many degrees we want to rotate something by, but instead want to rotate something so that it points to a given direction (vector)?
• To rotate to a direction given by another Transform, use the previously mentioned Transform.LookAt method:

  transform.LookAt(otherGameObject.transform);
  

• To rotate to a direction given by another vector, use Quaternion.LookRotation:

  transform.rotation = Quaternion.LookRotation(vector);
  

There's also Quaternion.FromToRotation for rotating a vector to align another vector

• E.g., here's how to sets the the transform's -axis (transform.up) to go along the directionVector

  transform.rotation = Quaternion.FromToRotation(transform.up, directionVector);
  

Extra: How to look slowly towards a point (3D)

To slowly rotate towards a target, there are two methods available:

• If you need to manipulate position vectors: Vector3.RotateTowards
• If you need to manipulate rotation quaternions: Quaternion.RotateTowards

Extra: How to instantly look towards a point (2D)

• The methods described in the previous slide do not (directly) work in 2D
• Even transform.LookAt(Transform target) does not work, because it aligns the transform.forward axis towards the target, which is the local axis - the one that points UP in 2D games!
• Instead, we want to align the transform.right axis towards the target:

  transform.right = target.transform.position - transform.position;
  

  (or if you want to use angles:)

  float angle = Mathf.Atan2(target.transform.position.y, target.transform.position.x) * Mathf.Rad2Deg;
  transform.rotation = Quaternion.Euler(new Vector3(0, 0, angle));
  

How to slowly look towards a point (2D)

• uhhhh xx todo

Changing many values at once

• You can select multiple GameObjects at once to edit their transforms values at once
• You can even set their position, rotation or scale to be a range of values by setting the field to L(lower, upper)
  • Other neat ways exist as well. R(lower, upper) sets the values to a random range, and you can multiply all values at once with +=value
• See other numeric field expressions in the Unity docs