koobas.hobune.stream
Smooth Rotation
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);
}
}
// 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.
there are a lot of instances where coroutines are useful. especially for over the time actions, i always prefer this. well i got the habit of using coroutines a lot after working with php scripts in unity. even i wanted to knw which one would be effective.
can someone please change both these scripts into javascript?
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
}
