Smooth Rotation

Questions & Answers
1

I know this is a common problem and I have searched the forums for help but I am still having trouble. Right now the user has one object in front of them and one object behind them. When the user holds T the camera looks back at the object behind the user. When the user releases T they look at the object in front of them.

I am trying to have the camera smoothly rotate towards the objects instead of jumping to the objects. Any help is appreciated. My code is below.

using UnityEngine;
using System.Collections;

public class Rotate2 : MonoBehaviour {
public Transform target;
public Transform target2;

// Use this for initialization
void Start () {

}

// Update is called once per frame
void Update () {
	 if (Input.GetKeyDown(KeyCode.T))
		transform.LookAt(target);
	
	if (Input.GetKeyUp(KeyCode.T))
		transform.LookAt(target2);

}

}
2

// call this once somewhere in the code
StartCoroutine(“MyLerp”, fromRot,toRot,time);

function MyLerp(fromRot:Quaternion,toRot:Quaternion,time:float) : IEnumerator      // i dont know if  :IEnumerator part is needed since i never used coroutine with js.  
{
    var t:float=0;
    while(t<1)
    {
        t+=time/Time.deltaTime;
        transform.rotation=Quaternion.Lerp(fromRot,toRot,t);
        yield;
    }
}

@hijinxbassist the problem with earlier function is t+=time/Time.deltaTime; this line the takes the same deltaTime and finishes the whole rotation sequence within a frame. damn im not good at explaining, but hope u get what i try to say. PS i stil dont knw the lerp thing is properly, i hope you got tht right.

3

The following code will use SmoothDamp for smooth rotation and is frame independent (I only have the script for C#):

public static Vector4 ToVector4 (this Quaternion quaternion) {
	return new Vector4 (quaternion.x, quaternion.y, quaternion.z, quaternion.w);
}

public static Quaternion ToQuaternion (this Vector4 vector) {
	return new Quaternion (vector.x, vector.y, vector.z, vector.w);
}

public static Vector4 SmoothDamp (Vector4 current, Vector4 target, ref Vector4 currentVelocity, float smoothTime) {
	float x = Mathf.SmoothDamp (current.x, target.x, ref currentVelocity.x, smoothTime);
	float y = Mathf.SmoothDamp (current.y, target.y, ref currentVelocity.y, smoothTime);
	float z = Mathf.SmoothDamp (current.z, target.z, ref currentVelocity.z, smoothTime);
	float w = Mathf.SmoothDamp (current.w, target.w, ref currentVelocity.w, smoothTime);

	return new Vector4 (x, y, z, w);
}

public static Quaternion SmoothDamp (Quaternion current, Quaternion target, ref Vector4 currentVelocity, float smoothTime) {
	Vector4 smooth = SmoothDamp (current.ToVector4 (), target.ToVector4 (), ref currentVelocity, smoothTime);
	return smooth.ToQuaternion ();
}

How to use it:

private Quaternion currentRotation; // The current rotation
private Quaternion targetRotation; // The rotation it is going towards
private float rotationV; // Current rotation velocity
private float smoothTime = 0.5f; // Smooth value between 0 and 1

void Start () {
	// Set currentRotation and targetRotation
	currentRotation = transform.position;
	targetRotation = someValue;
}

void Update () {
	currentRotation = SmoothDamp (currentRotation, targetRotation, ref rotationV, smoothTime); // Smoothly change the currentRotation towards the value of targetRotation
	
	transform.rotation = currentRotation; // Or whatever it is you are trying to rotate
}