How to change LookRotation so the y axis will always face the target position

Question

I have this script that points a missile's z+ axis at its target:

 public class Missile : MonoBehaviour
 {
     Vector3 target;
     public Transform car;

     void Update()
     {
         car = GameObject.FindGameObjectWithTag("Cube").transform;
         target = Vector3.Normalize(car.position - transform.position);
         Quaternion direction = Quaternion.LookRotation(target);
         transform.rotation = Quaternion.Slerp(transform.rotation, direction, 4*Time.deltaTime);
         transform.position = transform.position + 10* transform.up* Time.deltaTime;

     }
}

But my missile model has its "front" pointing in the direction of the y+ axis, not z.

How can I convert the LookRotation code above to rotate the y axis to my target, instead of the z? If possible, I'd love to see a diagram that explains how the conversion works.

I have referred to some previous answers about this topic, but still couldn't understand how to do it in this case.

Answer 1

Let's see if I can write a version of this answer so general-purpose that I never have to write another one. 😆

public static Quaternion OmniLookRotation(
             Vector3 exactAxis,       Vector3 exactTarget,
             Vector3 approximateAxis, Vector3 approximateTarget
) {
    // Compute a rotation that takes the z+ and y+ axes to our custom axes.
    var zyToCustom = Quaternion.LookRotation(exactAxis, approximateAxis);
    // Invert this, to map our custom axes to z+ and y+.
    var customToZY = Quaternion.Inverse(zyToCustom);

    // Compute a rotation that takes the z+ and y+ axes to our target directions.
    var zyToTarget = Quaternion.LookRotation(exactTarget, approximateTarget);
    
    // Chain these two rotations so that exactAxis maps to exactTarget,
    // and approximateAxis maps as closely as it can to approximateTarget.
    var customToTarget = zyToTarget * customToZY;

    return customToTarget;
}

So, let's say I want to point my local y+ axis (Vector3.up) exactly toward my target (let's call that toTarget to distinguish this offset from the target's absolute position), while pointing my local x+ axis (Vector3.right) as close as possible toward world "down" (Vector3.down). I'd write it like this:

var targetRotation = OmniLookRotation(
                       Vector3.up,    toTarget,    // "point my y+ at target"
                       Vector3.right, Vector3.down // "and my x+ down"
                   );

// This is already a non-linear, not correctly time-adjusted blend,
// so if we're being approximate anyway we may as well use Lerp
// and save the added cost of Slerp.
transform.rotation = Quaternion.Lerp(
                       transform.rotation, 
                       targetRotation,
                       4*Time.deltaTime
                   );

Answer 2

A quick and easy way to deal with a model not being lined up the way you want it is to make the game object with the model be a child of the game object that has the movement script. In this case, Change the local rotation of the child to orient the model's y axis along the parent object's z axis. That way, as your movement script points the parent object, the child will move with it. No fancy math needed.