Kamera Flip Problem

Question

Ich programmiere ein Spiel in C# die XNA3.1-Engine. Jedoch habe ich ein kleines Problem mit meiner Kamera habe, im Grunde meine Kamera „Flip“ neigt, wenn es mehr als 180 Grad auf seiner Rolle dreht (wenn die Kamera 180 Grad erreicht, so scheint es, wieder auf 0 Grad zu drehen). Der Code für die Ansichtsmatrix zu erhalten, ist wie folgt:

Globals.g_GameProcessingInfo.camera.viewMat = Matrix.CreateLookAt(Globals.g_GameProcessingInfo.camera.target.pos, Globals.g_GameProcessingInfo.camera.LookAt, up);    //Calculate the view matrix 

Die Globals.g_GameProcessingInfo.camera.LookAt Variable die Position 1 Einheit direkt vor der Kamera relativ zu der Drehung der Kamera, und die „up“ Variable wird mit dem erhaltenen folgende Funktion:

static Vector3 GetUp()  //Get the up Vector of the camera 
{ 
    Vector3 up = Vector3.Zero; 
    Quaternion quat = Quaternion.Identity; 
    Quaternion.CreateFromYawPitchRoll(Globals.g_GameProcessingInfo.camera.target.rot.Y, Globals.g_GameProcessingInfo.camera.target.rot.X, Globals.g_GameProcessingInfo.camera.target.rot.Z, out quat); 

    up.X = 2 * quat.X * quat.Y - 2 * quat.W * quat.Z;  //Set the up x-value based on the orientation of the camera 
    up.Y = 1 - 2 * quat.X * quat.Z - 2 * quat.Z * quat.Z; //Set the up y-value based on the orientation of the camera 
    up.Z = 2 * quat.Z * quat.Y + 2 * quat.W * quat.X;  //Set the up z-value based on the orientation of the camera 
    return up;  //Return the up Vector3 
} 

Answer 1

Ich habe dieselben Probleme in OpenGL mit gluLookAt. Ich habe das Problem mit meiner eigenen Kameraklasse behoben:

void Camera::ComputeVectors() 
{ 
    Matrix4x4 rotX, rotZ; 
    Quaternion q_x, q_y, q_z; 
    Quaternion q_yx, q_yz; 
    q_x.FromAngleAxis(radians.x, startAxisX); 
    q_y.FromAngleAxis(radians.y, startAxisY); 
    q_z.FromAngleAxis(radians.z, startAxisZ); 
    q_yx = q_y * q_x; 
    q_yx.ToMatrix(rotZ); 
    q_yz = q_y * q_z; 
    q_yz.ToMatrix(rotX); 
    axisX = startAxisX; 
    axisZ = startAxisZ; 
    axisX.Transform(rotX); 
    axisZ.Transform(rotZ); 
    axisY = axisX.Cross(axisZ); 

    position = startPosition; 
    position -= center; 
    position.Transform(q_yx); 
    position += center; 
} 

Es ist vielleicht zu kompliziert, aber funktioniert. axisY ist Ihr hoher Vektor. Vollständige Codeauflistung ist an: http://github.com/filipkunc/opengl-editor-cocoa/blob/master/PureCpp/MathCore/Camera.cpp

Hoffnung hilft es.

Answer 2

meh hatte gehofft, dort irgendwo eine Bräune zu sehen.

können Sie einen Link, wo Sie Ihre Gleichung bekam von bitte? (bin bei der Arbeit und wirklich don; t wollen mich hinsetzen und ableiten)

Wie stellen Sie Ihre Kameradrehung ein? Bist du sicher, dass dort nichts läuft?

Answer 3

Ich bin ein wenig unsicher über die Mathematik in Ihrer GetUp Methode. Können Sie die Mathematik dahinter erläutern?

In meiner lookat Kamera initialisieren ich meine up-Vektor einmal und drehen dann diesen Vektor ein quaternion verwenden. Dies beseitigt die Möglichkeit, zu versuchen, ein Kreuzprodukt auf parallele Vektoren zu tun, um den Aufwärts-Vektor zu berechnen.

Einige semicode zu klären, vielleicht:

var up = Vector3.Up; 
var target = <some point in space>; 
var rotation = <current rotation quaternion>; 

var forward = target - position; 
forward = Vector3.Transform(forward, rotation); 

var updatedPosition = target - forward; 
var updatedUp = Vector3.Transform(up, rotation); 

var view = Matrix.CreateLookAt(updatedPosition, target, updatedUp); 

Answer 4

Dies ist wahrscheinlich langsamer, aber der einzige Weg, ich mit dem zu tun wissen, wäre die mit der Rotationsmatrix für 3D. Wikipedia Link

Wo

und U = (Camera.position - Camera.lookat) .norm

... Nun, ich glaube, dass Sie würde die Rotationsteil der Ansichtsmatrix. Aber ich bin nicht 100% darauf. Ich denke aber immer noch darüber nach.

Answer 5

Da ich mit den Antworten hier schon nicht zufrieden war, musste ich das selbst herausfinden.

Was ich entdeckte, ist es eigentlich ziemlich einfach. Tun Sie dies einfach:

Matrix ypr = Matrix.CreateFromYawPitchRoll(yaw, pitch, roll); 
Vector3 up = Vector3.Transform(Vector3.Up, ypr); 

"oben" ist die Richtung, die Sie wollen.