Orientamento di un modello per affrontare un obiettivo

Ho due oggetti (bersaglio e giocatore), entrambi hanno Posizione (Vector3) e Rotazione (Quaternion). Voglio che il bersaglio ruoti e sia rivolto verso il giocatore. Il bersaglio, quando spara qualcosa, dovrebbe sparare direttamente al giocatore.

Ho visto un sacco di esempi di slerping per il giocatore, ma non voglio una rotazione incrementale, beh, suppongo che sarebbe ok fintanto che potrò rendere lo slerp al 100% e finché funzionerà davvero.

Cordiali saluti - Sono in grado di utilizzare la posizione e la rotazione per fare molte altre cose e tutto funziona alla grande tranne questo ultimo pezzo che non riesco a capire.

I campioni di codice vengono eseguiti nella classe del bersaglio, Posizione = posizione del bersaglio, Avatar = giocatore.

MODIFICARE

Ora sto usando il codice c # di Maik che ha fornito e funziona benissimo!

Esistono più modi per farlo. Puoi calcolare l'orientamento assoluto o la rotazione relativa al tuo avatar, ciò significa che il tuo nuovo orientamento = avatarOrientation * q. Ecco l'ultimo:

1. Calcola l'asse di rotazione portando il prodotto incrociato del vettore in avanti dell'unità del tuo avatar e il vettore di unità dall'avatar al target, il nuovo vettore in avanti:

   vector newForwardUnit = vector::normalize(target - avatarPosition);
   vector rotAxis = vector::cross(avatarForwardUnit, newForwardUnit);
   

2. Calcola l'angolo di rotazione usando il punto-prodotto

   float rotAngle = acos(vector::dot(avatarForwardUnit, newForwardUnit));

3. Crea il quaternione usando rotAxis e rotAngle e moltiplicalo con l'orientamento corrente dell'avatar

   quaternion q(rotAxis, rotAngle);
   quaternion newRot = avatarRot * q;
   

Se hai bisogno di aiuto per trovare l'attuale vettore in avanti dell'avatar, l'ingresso per 1. basta sparare :)

EDIT: il calcolo dell'orientamento assoluto è in realtà un po 'più semplice, usa il vettore in avanti della matrice identità invece del vettore in avanti degli avatar come input per 1) e 2). E non moltiplicarlo per 3), invece utilizzalo direttamente come nuovo orientamento:newRot = q

Importante da notare: la soluzione presenta 2 anomalie causate dalla natura del prodotto incrociato:

1. Se i vettori in avanti sono uguali. La soluzione qui è semplicemente restituire il quaternione identità

2. Se i vettori puntano esattamente nella direzione opposta. La soluzione qui è quella di creare il quaternione usando gli avatar sull'asse come asse di rotazione e l'angolo di 180,0 gradi.

Ecco l'implementazione in C ++ che si occupa di quei casi limite. La conversione in C # dovrebbe essere facile.

// returns a quaternion that rotates vector a to vector b
quaternion get_rotation(const vector &a, const vector &b, const vector &up)
{   
    ASSERT_VECTOR_NORMALIZED(a);
    ASSERT_VECTOR_NORMALIZED(b);

    float dot = vector::dot(a, b);    
    // test for dot -1
    if(nearly_equal_eps_f(dot, -1.0f, 0.000001f))
    {
        // vector a and b point exactly in the opposite direction, 
        // so it is a 180 degrees turn around the up-axis
        return quaternion(up, gdeg2rad(180.0f));
    }
    // test for dot 1
    else if(nearly_equal_eps_f(dot, 1.0f, 0.000001f))
    {
        // vector a and b point exactly in the same direction
        // so we return the identity quaternion
        return quaternion(0.0f, 0.0f, 0.0f, 1.0f);
    }

    float rotAngle = acos(dot);
    vector rotAxis = vector::cross(a, b);
    rotAxis = vector::normalize(rotAxis);
    return quaternion(rotAxis, rotAngle);
}

EDIT: versione corretta del codice XNA di Marc

// the new forward vector, so the avatar faces the target
Vector3 newForward = Vector3.Normalize(Position - GameState.Avatar.Position);
// calc the rotation so the avatar faces the target
Rotation = Helpers.GetRotation(Vector3.Forward, newForward, Vector3.Up);
Cannon.Shoot(Position, Rotation, this);


public static Quaternion GetRotation(Vector3 source, Vector3 dest, Vector3 up)
{
    float dot = Vector3.Dot(source, dest);

    if (Math.Abs(dot - (-1.0f)) < 0.000001f)
    {
        // vector a and b point exactly in the opposite direction, 
        // so it is a 180 degrees turn around the up-axis
        return new Quaternion(up, MathHelper.ToRadians(180.0f));
    }
    if (Math.Abs(dot - (1.0f)) < 0.000001f)
    {
        // vector a and b point exactly in the same direction
        // so we return the identity quaternion
        return Quaternion.Identity;
    }

    float rotAngle = (float)Math.Acos(dot);
    Vector3 rotAxis = Vector3.Cross(source, dest);
    rotAxis = Vector3.Normalize(rotAxis);
    return Quaternion.CreateFromAxisAngle(rotAxis, rotAngle);
}