title: Quaternion lookRotation - upwards doesn't work
body: <p>I'm trying to make a bird rotate a bit "realistic", which is, vector up should point to the angle rotated, I mean, if you rotate 90º to your local right, vector up should now point -vector.forward (the one you had before rotating).</p>
  
  <p>I tried with a function, but it only rotates sometimes, the rest, it just overwrites the vector.up as if it was 0,1,0.</p>
  
  <pre><code>using System.Collections;
   using System.Collections.Generic;
   using UnityEngine;
  
   public class SmoothPath : MonoBehaviour {
  
       [System.Serializable]
       public class TrackingSettings
       {
           [HideInInspector]
           public int currentPoint = 0;
           [HideInInspector]
           public int nextPoint = 1;
           public int pathToFollow = 0;
           public GameObject affectedObject;
           public float speed = 10;
           public float rotationSpeed = 12;
           [HideInInspector]
           public Quaternion lastRotation;
           [HideInInspector]
           public Vector3 lastLocation;
       }
  
       [System.Serializable]
       public class PathsToFollow
       {
           public GameObject pathReference;
           public Transform[] pathPoints;
       }
  
       public TrackingSettings[] objectsToTrack;
       private TrackingSettings tempObjectToTrack;
       private float timer = 0;
  
       public PathsToFollow[] pathsToFollow;
  
       private Quaternion lookRotation;
       private Transform currentNode;
       private Transform nextNode;
       private float distance;
  
       // Use this for initialization
       void Start()
       {
           foreach (TrackingSettings ts in objectsToTrack)
           {
               ts.currentPoint = 0;
               ts.nextPoint = 1;
               ts.affectedObject.transform.position = pathsToFollow[ts.pathToFollow].pathPoints[0].position;
               ts.lastRotation = ts.affectedObject.transform.rotation;
               ts.lastLocation = ts.affectedObject.transform.position;
               lookRotation = Quaternion.LookRotation(pathsToFollow[ts.pathToFollow].pathPoints[1].position - pathsToFollow[ts.pathToFollow].pathPoints[0].position);
               ts.affectedObject.transform.rotation = lookRotation;
  
               currentNode = pathsToFollow[ts.pathToFollow].pathPoints[ts.currentPoint];
               nextNode = pathsToFollow[ts.pathToFollow].pathPoints[ts.nextPoint];
  
               distance = Vector3.Distance(currentNode.position, nextNode.position);
           }
       }
  
       // Update is called once per frame
       void Update () {
           timer += Time.deltaTime;
           for (int i = 0; i &lt; objectsToTrack.Length; i++)
           {
               tempObjectToTrack = objectsToTrack[i];
  
               if (Vector3.Distance(tempObjectToTrack.affectedObject.transform.position, nextNode.position) &lt; 0.3f)
               {
  
                   tempObjectToTrack.currentPoint = tempObjectToTrack.nextPoint;
                   tempObjectToTrack.nextPoint++;
                   //reset if overflow
                   if (tempObjectToTrack.nextPoint == pathsToFollow[tempObjectToTrack.pathToFollow].pathPoints.Length) tempObjectToTrack.nextPoint = 0;
  
                   timer = 0;
  
                   //lastNode = pathsToFollow[tempObjectToTrack.pathToFollow].pathPoints[tempObjectToTrack.lastPoint];
                   currentNode = pathsToFollow[tempObjectToTrack.pathToFollow].pathPoints[tempObjectToTrack.currentPoint];
                   nextNode = pathsToFollow[tempObjectToTrack.pathToFollow].pathPoints[tempObjectToTrack.nextPoint];
  
                   distance = Vector3.Distance(currentNode.position, nextNode.position);
  
                   float angle = GetAngle(tempObjectToTrack.affectedObject.transform.forward, Vector3.Normalize(nextNode.position - currentNode.position));
  
                   //set last rotation and location
                   tempObjectToTrack.lastRotation = tempObjectToTrack.affectedObject.transform.localRotation; 
                   tempObjectToTrack.lastLocation = tempObjectToTrack.affectedObject.transform.position;
  
                   tempObjectToTrack.affectedObject.transform.up = new Vector3(angle / 2, 45, 0);
                   lookRotation = Quaternion.LookRotation(nextNode.position - tempObjectToTrack.affectedObject.transform.position, new Vector3(angle / 2, 45, 0));
                   Debug.Log("Up: " + new Vector3(angle / 2, 45, 0) + " - angle: " + angle);
                   //tempObjectToTrack.affectedObject.transform.localRotation = lookRotation;
               }
  
               tempObjectToTrack.affectedObject.transform.position = Vector3.SlerpUnclamped(tempObjectToTrack.lastLocation, nextNode.position, timer / distance * tempObjectToTrack.speed);
  
               tempObjectToTrack.affectedObject.transform.rotation = Quaternion.Slerp (tempObjectToTrack.lastRotation, lookRotation, timer / distance * tempObjectToTrack.rotationSpeed);
  
  
           }
  
  
       }
  
       private float GetAngle(Vector3 a, Vector3 b)
       {
           b.y = 0;
           a.y = 0;
           float angle = Vector3.Angle(a, b);
           float sign = Mathf.Sign(Vector3.Dot(Vector3.up, Vector3.Cross(a, b)));
  
           return angle * sign;
       }
   }
  </code></pre>
  
  <p>in a circle path (4 waypoints or more in squared way / round), the bird sometimes points properly and some others it doesn't</p>