unity rotation issue on parent rotation
Solution 1
So my guess, gimbal lock, like said in the other answer. However, I'm not sure I would try to fix THAT, considering you are passing quaternion to euler and vise versa. If I had to do it, I wouldn't do it the way you did, since using quaternion for parenting between objects is equal to massive headache.
First, while you are parenting objects, you are not using that feature! This is a very solid feature from Unity. Unity Parenting: http://docs.unity3d.com/Documentation/ScriptReference/Transform-parent.html
Each of your turret objects only rotate in a single local axis. And Unity is built to handle that: http://docs.unity3d.com/Documentation/ScriptReference/Transform-localRotation.html
When an object is parented to another, you can rotate it locally in the axis you want. Unity handle the overall matrix transformation on its own. When you are modifying the global rotation of the object, you are basically overriding the transformation coming from the parenting. At this point, it's very easy for any hierarchy to gain error and imprecision over time.
EDIT: With your package, I was able to write what I meant:
public class WeaponMover : MonoBehaviour
{
public GameObject boat;
public GameObject turretRotateObj;
public GameObject towerRotateObj;
public GameObject target;
private Vector3 lastDirection;
// initialization
void Start()
{
lastDirection = boat.transform.forward;
}
void Update()
{
// Find direction toward our target. Use turret as origin.
Vector3 wantedDirection = target.transform.position - turretRotateObj.transform.position;
// Rotate our last direction toward that new best direction. Change floats to make it move faster or slower.
lastDirection = Vector3.RotateTowards(lastDirection, wantedDirection, 0.01f, 0.01f);
// Find the direction local to the tower as the boat can move around!
Vector3 towerDirection = boat.transform.InverseTransformDirection(lastDirection);
// Remove unwanted axis
towerDirection = new Vector3(-towerDirection.z, 0, towerDirection.x);
towerDirection.Normalize();
// Set local rotation
towerRotateObj.transform.localRotation = Quaternion.LookRotation(towerDirection);
// Find the direction local to the gun, as the tower may have rotated!
Vector3 turretDirection = towerRotateObj.transform.InverseTransformDirection(lastDirection);
// Remove unwanted axis.
turretDirection = new Vector3(turretDirection.x, turretDirection.y, 0);
turretDirection.Normalize();
// Set local rotation
turretRotateObj.transform.localRotation = Quaternion.LookRotation(turretDirection);
}
}
Note: I had to move the gun's barrel to the Z axis instead of the X axis because I was lazy. So if you only copy paste this code, the barrel will be pointing toward the frame, but the gun will follow the target correctly.
Since the rotation are now local, you can spin the ship for years, and the gun will never get any offset.
Solution 2
Well I am not sure but it seems like you are running into Gimbal Lock problem. Although your calculations start from quaternions it might be possible that the two calls to Mathf.SmoothDampAngle
are the root cause on the long run.
So I would suggest to first remove all smoothing and then, if this turned out to be the culprit, replace these methods by pure quaternion based method like Quaternion.Slerp.
immerhart
Updated on June 04, 2022Comments
-
immerhart almost 2 years
at first, here the video of the problem: link to video, here the package and here is a screenshot of the hierachey: the GUN is the parent with the script(empty gameobject) Suspension gets dropped to the
towerRotateObj
and Gun gets dropped on theturretRotateObj
. Suspension and Gun are also empty gameobjects. they are just some kind of group objects and here the code:public class WeaponMover : MonoBehaviour { public Transform target; public GameObject turretRotateObj; public GameObject towerRotateObj; public float maxTowerRotationSpeed = 360.0f; public float maxTurretRotationSpeed = 360.0f; public float smoothFactorTower = 0.125f; public float smoothFactorTurret = 0.125f; public float maxTowerRotation = 130.0f; public float maxTurretRotation = 50.0f; private Vector3 m_newRotation; private Vector3 m_angles; private float m_minTowerAngle; private float m_maxTowerAngle; private float m_minTurretAngle; private float m_maxTurretAngle; private float m_velTower; private float m_velTurret; private bool m_isTransNecTower = false; private bool m_isTransNecTurret = false; // initialization void Start() { m_newRotation = Vector3.zero; m_angles = Vector3.zero; m_maxTowerAngle = towerRotateObj.transform.eulerAngles.y + maxTowerRotation/2; m_minTowerAngle = towerRotateObj.transform.eulerAngles.y - maxTowerRotation/2; m_maxTurretAngle = turretRotateObj.transform.eulerAngles.z + maxTurretRotation/2; m_minTurretAngle = turretRotateObj.transform.eulerAngles.z - maxTurretRotation/2; // check if rotation happens between 0/360 // tower if(m_minTowerAngle <= 0.0f) m_minTowerAngle += 360.0f; if(m_maxTowerAngle >= 360.0f) m_maxTowerAngle -= 360.0f; if(m_minTowerAngle > m_maxTowerAngle) m_isTransNecTower = true; // turret if(m_minTurretAngle <= 0.0f) m_minTurretAngle += 360.0f; if(m_maxTurretAngle >= 360.0f) m_maxTurretAngle -= 360.0f; if(m_minTurretAngle > m_maxTurretAngle) m_isTransNecTurret = true; } void Update() { m_newRotation = Quaternion.LookRotation(target.position - towerRotateObj.transform.position).eulerAngles; m_angles = towerRotateObj.transform.rotation.eulerAngles; towerRotateObj.transform.rotation = Quaternion.Euler(m_angles.x, ClampAngle(Mathf.SmoothDampAngle(m_angles.y, m_newRotation.y - 90.0f, ref m_velTower, smoothFactorTower, maxTowerRotationSpeed), m_minTowerAngle, m_maxTowerAngle, m_isTransNecTower), m_angles.z); m_newRotation = Quaternion.LookRotation(target.position - turretRotateObj.transform.position).eulerAngles; m_angles = turretRotateObj.transform.rotation.eulerAngles; turretRotateObj.transform.rotation = Quaternion.Euler(m_angles.x, m_angles.y, ClampAngle(Mathf.SmoothDampAngle(m_angles.z, -m_newRotation.x, ref m_velTurret, smoothFactorTurret, maxTurretRotationSpeed), m_minTurretAngle, maxTurretRotation, m_isTransNecTurret)); } private float ClampAngle(float angle, float min, float max, bool isTranslationNecessary) { if(!isTranslationNecessary) { if(angle < min ) return min; if(angle > max) return max; } else { if(angle > max && angle < min) { if(min - angle > angle - max) return max; else return min; } } return angle; } }
so, it a similar setup, like the tower and gun of a tank.... i have posted that question already here, but it seems like few people seen the post... any advice is appreciated! thanks.
update:
m_newRotation = Quaternion.LookRotation(m_target.transform.position - towerRotateObj.transform.position).eulerAngles; m_newRotation.y -= 90f; m_angles = towerRotateObj.transform.rotation.eulerAngles; towerRotateObj.transform.rotation = Quaternion.Euler(m_angles.x, m_newRotation.y, m_angles.z); m_newRotation = Quaternion.LookRotation(m_target.transform.position - turretRotateObj.transform.position).eulerAngles; m_angles = turretRotateObj.transform.rotation.eulerAngles; turretRotateObj.transform.rotation = Quaternion.Euler(m_angles.x, m_angles.y, -m_newRotation.x);
the problem stays the same :(