koobas.hobune.stream
Rotate the shortest way?
Hi there..
I got stuck in a problem.. I´ve written this small code to rotate my player smoothly into a given direction:'
void Rotate_to(){
rotate_t += Time.deltaTime * RotateSpeed;
PlayerHolder.transform.eulerAngles = new Vector3(0, Mathf.Lerp(PlayerHolder.transform.eulerAngles.y, new_direction, rotate_t), 0);
}
The problem is: He is rotating always to the right.. if the players rotation is at 45°, and he needs to rotate to -45° (315°), he is rotating rightways.. instead of the shorter left way..
So i tried for some time now, to ask for the shorter way.. But couldn´t find an answer... I heard of Mathf.DeltaAngle or asking for Mathf.Abs differences.. But it´s not working..
Can someone help me out here? :(
The complete code: Third Person Controller (Pastebin.com)
or use Mathf.LerpAngle :)
This is what I was looking for and the simplest solution. Thanks!
Here, I wrote these functions for your needs:
// If the return value is positive, then rotate to the left. Else,
// rotate to the right.
float CalcShortestRot(float from, float to)
{
// If from or to is a negative, we have to recalculate them.
// For an example, if from = -45 then from(-45) + 360 = 315.
if(from < 0) {
from += 360;
}
if(to < 0) {
to += 360;
}
// Do not rotate if from == to.
if(from == to ||
from == 0 && to == 360 ||
from == 360 && to == 0)
{
return 0;
}
// Pre-calculate left and right.
float left = (360 - from) + to;
float right = from - to;
// If from < to, re-calculate left and right.
if(from < to) {
if(to > 0) {
left = to - from;
right = (360 - to) + from;
} else {
left = (360 - to) + from;
right = to - from;
}
}
// Determine the shortest direction.
return ((left <= right) ? left : (right * -1));
}
// Call CalcShortestRot and check its return value.
// If CalcShortestRot returns a positive value, then this function
// will return true for left. Else, false for right.
bool CalcShortestRotDirection(float from, float to)
{
// If the value is positive, return true (left).
if(CalcShortestRot(from, to) >= 0) {
return true;
}
return false; // right
}
Example:
void Update()
{
// The turn direction should be right.
Debug.Log("Turn direction: " + (CalcShortestRotDirection(45, -45) ? "Left" : "Right"));
// Turn -90.
Debug.Log("Turn value: " + CalcShortestRot(45, -45));
// The turn direction should be left.
Debug.Log("Turn direction: " + (CalcShortestRotDirection(45, 90) ? "Left" : "Right"));
// Turn +45.
Debug.Log("Turn value: " + CalcShortestRot(45, 90));
}
Please don't forget to read the comments.
i tried the code now.. But it just gives me a direction where it´s shorter.. $$anonymous$$y character is still turning into the long ways.. cause your code doesn´t change the calculation of the lerp things ._.
I don't see any problem with the approach. For the OPs use, you'd have to take it further and construct normalized beginning and end points, or you would have to redo his code to use relative rather than absolute rotations. You did not know this was necessary when you answered. +1 for spotting the real problem first and having a workable approach.
Both Mathf.Lerp() and Vector3.Lerp() are literal, so you have to give it values that make the code rotate the way you want. Let me start with a quick patch to your code:
void Rotate_to(){
rotate_t += Time.deltaTime * RotateSpeed;
float f = PlayHolder.transform.eulerAngles.y;
if (f > 180.0f)
f -= 360.0f;
PlayerHolder.transform.eulerAngles = new Vector3(0, Mathf.Lerp(f, new_direction, rotate_t), 0);
}
The code takes the eulerAngles.y value and normalized it to -180 to 180, so now a -45 will rotate in the correct direction. But reading eulerAngles has issues. As long as the X and Z rotation is 0, your code should work fine. But if you start combining this rotation with an X and Z rotations, then you may run into serious issues. The problem is that eulerAngles is derived from Transform.rotation (a Quaternion) and the values output may not stay in the expected representation. Assuming this is the only code changing the rotation of the object, a safer method would be to maintain your own Vector3 and treat eulerAngles as write only. So at the top of the class you declare:
Vector3 myRotation = Vector3.zero;
Then your Rotate_to() becomes:
void Rotate_to(){
rotate_t += Time.deltaTime * RotateSpeed;
myRotation.y = Mathf.Lerp(myRotation.y, new_direction, rotate_t);
PlayerHolder.transform.eulerAngles = myRotation;
}
You can use myRotation.y because it will always be in the representation you set it to. So if you use -180 to 180, those are the values you will read back. On the other hand, if you set eulerAngles to -45, you are going to get 315 back.
The second way with myRotation is not really working.. When looking left (new_direction = 270), and want to look up to 0, he still rotates leftways about 270°, ins$$anonymous$$d of 90° rightways.
The first way makes the object shake and hang when trying to look left.
Can you post the rest of your modified script? I'll take a look and see what is going on.
I see one problem right off. To make this work your 'new_direction' settings have to be normalized into -180 to 180 values as well. So ins$$anonymous$$d of 315, you use -45 for example. Think about Lerp() being literal then compare the start and end angles. Lerp() will happily march from one value to the other no matter what their values (and will not take the 0/360 boundry into account). At times it is a pain. At times it is great. For example, consider wanting to make a rotation of 720 degrees.
Okay. $$anonymous$$y suggestion for fixing this problem is to use Quaternions rather than angles and Lerp. Below I've taken your key logic and use it to build a Quaternion for each rotation. The actual rotation is just a single line of code. No need to calculate the shortest angle distance. No need to deal with the 0/360 boundary. You'll need to understand and then integrate this logic back into your code. Before you do that, 1) create a new scene, 2) create a cube, 3) attach this script and play.
using UnityEngine;
using System.Collections;
public class Bug30 : $$anonymous$$onoBehaviour {
public float speed = 75.0f;
private Quaternion qTo;
void Start() {
qTo = transform.rotation;
}
void Update () {
if(Input.Get$$anonymous$$ey($$anonymous$$eyCode.RightArrow) || Input.Get$$anonymous$$ey($$anonymous$$eyCode.D)) // Rechts
{
if(Input.Get$$anonymous$$ey($$anonymous$$eyCode.UpArrow) || Input.Get$$anonymous$$ey($$anonymous$$eyCode.W)){ // Für Diagonale
qTo = Quaternion.Euler(0,45,0);
}
else if(Input.Get$$anonymous$$ey($$anonymous$$eyCode.DownArrow) || Input.Get$$anonymous$$ey($$anonymous$$eyCode.S)){
qTo = Quaternion.Euler(0,135,0);
}
else{
qTo = Quaternion.Euler(0,90,0);
}
}
else if(Input.Get$$anonymous$$ey($$anonymous$$eyCode.LeftArrow) || Input.Get$$anonymous$$ey($$anonymous$$eyCode.A)) // Links
{
if(Input.Get$$anonymous$$ey($$anonymous$$eyCode.UpArrow) || Input.Get$$anonymous$$ey($$anonymous$$eyCode.W)){ // Für Diagonale
qTo = Quaternion.Euler(0,315,0);
}
else if(Input.Get$$anonymous$$ey($$anonymous$$eyCode.DownArrow) || Input.Get$$anonymous$$ey($$anonymous$$eyCode.S)){
qTo = Quaternion.Euler(0,225,0);
}
else{
qTo = Quaternion.Euler(0,270,0);
}
}
else if(Input.Get$$anonymous$$ey($$anonymous$$eyCode.UpArrow) || Input.Get$$anonymous$$ey($$anonymous$$eyCode.W)) // Hoch
{
if(Input.Get$$anonymous$$ey($$anonymous$$eyCode.LeftArrow) || Input.Get$$anonymous$$ey($$anonymous$$eyCode.A)){ // Für Diagonale
qTo = Quaternion.Euler(0,315,0);
}
else if(Input.Get$$anonymous$$ey($$anonymous$$eyCode.RightArrow) || Input.Get$$anonymous$$ey($$anonymous$$eyCode.D)){
qTo = Quaternion.Euler(0,45,0);
}
else{
qTo = Quaternion.Euler(0,0,0);
}
}
else if(Input.Get$$anonymous$$ey($$anonymous$$eyCode.DownArrow) || Input.Get$$anonymous$$ey($$anonymous$$eyCode.S)) // Runter
{
if(Input.Get$$anonymous$$ey($$anonymous$$eyCode.LeftArrow) || Input.Get$$anonymous$$ey($$anonymous$$eyCode.A)){ // Für Diagonale
qTo = Quaternion.Euler(0,255,0);
}
else if(Input.Get$$anonymous$$ey($$anonymous$$eyCode.RightArrow) || Input.Get$$anonymous$$ey($$anonymous$$eyCode.D)){
qTo = Quaternion.Euler(0,135,0);
}
else{
qTo = Quaternion.Euler(0,180,0);
}
}
transform.rotation = Quaternion.RotateTowards(transform.rotation, qTo, Time.deltaTime * speed);
}
}
Old question, API must have changed. I'm using this to great effect:
bool left = Mathf.DeltaAngle(currentAngle, targetAngle) < 0f;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class RotateQuaNoneShortWay : MonoBehaviour
{
public float rotateAngle;
public float speed;
Quaternion targetRot;
float targetAngle;
float currentAngle;
Quaternion firstRotation;
public bool canRotate;
Transform c_Transform;
private void Start()
{
c_Transform = GetComponent<Transform>();
firstRotation = c_Transform.rotation;
}
void Update()
{
if (Input.GetKeyDown(KeyCode.R))
{
targetAngle += rotateAngle;
if (!canRotate)
{
firstRotation = c_Transform.rotation;
canRotate = true;
}
}
if (canRotate)
{
currentAngle = Mathf.Lerp(currentAngle, targetAngle, Time.deltaTime * speed);
targetRot = Quaternion.AngleAxis(currentAngle, c_Transform.up) * firstRotation;
c_Transform.rotation = Quaternion.Slerp(c_Transform.rotation, targetRot, Time.deltaTime * speed);
if (Quaternion.Angle(c_Transform.rotation,targetRot) < 0.2f)
{
c_Transform.rotation = targetRot;
currentAngle = 0;
targetAngle = 0;
canRotate = false;
}
}
}
}
