Rotate using physics

Ok, made it work without PID controller, but both @aldonaletto posts were very helpful. PID is most useful when you don't know how system reacts to input. But as we actually know how system reacts and it is pretty linear, it is possible to fit control system to Unity's physics engine.

Idea behind solution is following. We know how system reacts to acceleration and deceleration, so in each moment we can tell when objects stops spinning with current angular velocity. So in each update we determine angle remaining, current angular velocity and using this data, we decide whether to accelerate or decelerate. Do it separately for both axes and you have pretty precise controller. There are few things to note. First, Unity returns angles in degrees/s, but angular velocity in radians/s. Second, you need to consider current angular velocity when deciding to rotate right or left, for example. It may be faster to continue rotating instead of trying to stop and reverse rotation. The code uses speed bonus/penalty, first considering how would it be when idle, then adding time cost for reaching idle state, or substracting time cost needed to accelerate to current speed (both are same). And third, systems gets unstable if rotating too fast. If system can't stop rotation in 1/2 of spin, it will try to slow down, overshoots neutral zone and starts accelerating again. So you need to implement slowdown code (ommited as it is rather simple). Mine decelerates if speed is too high. Too high speed is computed into _maxAngularVelocity variable. Better to slowdown both axes, or at least don't accelerate the other. Also you way want to counter rotation around forward axis.

So far it works well even with angular damping of 0.

 public float angularForce = 1.0f; // this is how strong are your rotation thrusters
 void Start () {
     _acceleration = anguarForce / rigidbody.mass;
     // compute max angular velocity so it can be decelerated in 1/2 rotation (PI angle)
     _maxAngularVelocity = Mathf.Sqrt(_acceleration * Mathf.PI);
 }
 
 void FixedUpdate() {
     Vector3 targetDirection = currentTarget - transform.position;
     // get direction to target in local coordinates
     Vector3 localDirection = transform.InverseTransformDirection(targetDirection);        
     Vector3 angularVelocity = transform.InverseTransformDirection(rigidbody.angularVelocity);
 
     float upAxisSpeed = angularVelocity.y;
     float rightAxisSpeed = angularVelocity.x;
 
     // SLOWDOWN CODE HERE
 
     Vector2 upAxisVector = new Vector2(localDirection.x, localDirection.z).normalized; // vector in X-Z plane
     float upAxisAngle = Vector2.Angle(Vector2.up, upAxisVector) * Mathf.Deg2Rad;    // in degrees, convert to RADS!
     float upAxisStaticSign = Mathf.Sign(upAxisVector.x);
 
     // Same for Right axis = X
 
     forceUp = angularForce * GetAxisForce(upAxisAngle, upAxisSpeed, upAxisStaticSign);
     forceRight = angularForce * GetAxisForce(rightAxisAngle, rightAxisSpeed, rightAxisStaticSign);
 
     // apply forces
     rigidbody.AddRelativeTorque(forceUp * Vector3.up);
     rigidbody.AddRelativeTorque(forceRight * Vector3.right);
 }
 
 // this return 0, -1 or 1, meaning none or max force in either direction
 float GetAxisForce(float axisAngle, float axisSpeed, float directionSign, string axisLabel) {
     // this is direction of current rotation, helps to choose direction to reach target
     float dynamicCorrectionSign = Mathf.Sign(axisSpeed * directionSign);
     // this is how long will reach to stop from current velocity OR to accelerate from idle to current velocity
     float timeToStop = Mathf.Abs(axisSpeed / _acceleration);
     // how long would take to reach target in shorter direction if angular velocity is 0
     float staticToReach = Mathf.Sqrt(4 * axisAngle / _acceleration);
     float staticToReach2 = Mathf.Sqrt(4 * (2*Mathf.PI - axisAngle) / _acceleration); // same for longer direction
     // adjust these durations by current speed (this is basically integral part of velocity)
     float shorterTimeToReach = staticToReach - dynamicCorrectionSign * timeToStop;
     float longerTimeToReach = staticToReach2 + dynamicCorrectionSign * timeToStop;
         
     // choose direction, considering current velocity
     float force;
     float timeToReach;
     if (shorterTimeToReach <= longerTimeToReach) {
         force = directionSign;
         timeToReach = shorterTimeToReach;
     } else {
         force = -directionSign;
         timeToReach = longerTimeToReach;
     }
 
     // distance is small enough, consider target rotation reached (this pat could use more love)
     if (Mathf.Abs(timeToReach) < 0.1f) {
         // idle
         force = 0;
     } else if (timeToStop >= timeToReach) {
         // moving too fast, slow down
         force = -force;
     }
 
     return force;
 }

You have to assign a rigidbody component to the object and add torque, check this out:

http://unity3d.com/support/documentation/ScriptReference/Rigidbody.AddTorque.html

I'm also doing some space ship alike game with friction in the air -> rotation should also stop. I didn't get that ^ code working. What is currentTarget?

I made this kind of code to slow down the rotation of ship's axises:

 float slowDownPower = 10.0f;
 Vector3 localAngularVelocity = transform.InverseTransformDirection(gameObject.rigidbody.angularVelocity);
 gameObject.rigidbody.AddRelativeTorque(-localAngularVelocity * slowDownPower * Time.deltaTime);

It seems to work so far.

WOW, tried PID and I always got weird results, so I wrote my code :

to put in a file called PhysicsHelper.cs

 using UnityEngine;
 using System.Collections;
 
 public static class PhysicsHelper
 {
     
     public static void TorqueLookAtPoint(Rigidbody rigidbody, Vector3 point, float force, float damper = 0f)
     {
         Vector3 direction = point - rigidbody.position;
         TorqueLookToward(rigidbody, direction, force, damper);
     }
     public static void TorqueLookToward(Rigidbody rigidbody, Vector3 direction, float force, float damper = 0f)
     {
 
         Vector3 p = rigidbody.position;
         Vector3 forward = rigidbody.transform.forward; // axis we are rotating
 
         Vector3 cross = Vector3.Cross(forward, direction);
 
         float angleDiff = Vector3.Angle(forward, direction);
         angleDiff = Mathf.Sqrt(angleDiff);
         
         rigidbody.AddTorque(cross * angleDiff * force, ForceMode.Acceleration);
         rigidbody.AddTorque(-rigidbody.angularVelocity * damper, ForceMode.Acceleration);
         //rigidbody.AddTorque(cross * angleDiff * force);
 
         //Debug.Log(direction);
         //Debug.DrawLine(p, p + direction.normalized, Color.yellow, .05f);
         //Debug.DrawLine(p, p + rigidbody.angularVelocity, Color.yellow);
         //Debug.DrawLine(p, p + new Vector3(rigidbody.angularVelocity.x, 0, 0), Color.red);
         //Debug.DrawLine(p, p + new Vector3(0,rigidbody.angularVelocity.y, 0), Color.green);
         //Debug.DrawLine(p, p + new Vector3(0,0,rigidbody.angularVelocity.z), Color.blue);
     }
 
 }

Example of use :

         Rigidbody rigid = transform.GetComponent<Rigidbody>();
         Vector3 direction = Vector3.one;
         float force = 100f / Time.fixedDeltaTime;
         float damper = 50f;
         PhysicsHelper.TorqueLookToward(rigid, direction, force, damper);

Finally just adjust the force and set the dampening to not have your object's direction pass the direction and have a spring effect.

It may fit for most of your cases, with a minimum problems

Beware, if you'd like to change the deltatime per example, the force changes and needed dampening too (but it's just proportional to speed). Anyway, best solution I've found

>>> GIF <<<