कैमरा फ्लिप समस्या

Question

मैं XNA3.1 इंजन का उपयोग कर सी # में एक गेम प्रोग्रामिंग कर रहा हूं। हालांकि मुझे अपने कैमरे के साथ एक छोटी सी समस्या है, मूल रूप से मेरा कैमरा "फ्लिप" करता है जब यह अपने रोल पर 180 डिग्री से अधिक घूमता है (जब कैमरा 180 डिग्री तक पहुंच जाता है, तो यह 0 डिग्री तक वापस आ जाता है)।

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

Globals.g_GameProcessingInfo.camera.LookAt चर स्थिति 1 यूनिट कैमरा, कैमरा के रोटेशन के सापेक्ष के ठीक सामने है, और "ऊपर" चर के साथ प्राप्त की है: दृश्य मैट्रिक्स प्राप्त करने के लिए कोड इस प्रकार है निम्नलिखित कार्य:

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

मुझे gluLookAt के साथ ओपनजीएल में एक ही समस्या है। मैंने अपनी खुद की कैमरा कक्षा के साथ उस समस्या को ठीक किया:

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; 
} 

यह शायद अधिक जटिल है, लेकिन काम कर रहा है। axisY आपका अप वेक्टर है। पूर्ण कोड लिस्टिंग यहां है: http://github.com/filipkunc/opengl-editor-cocoa/blob/master/PureCpp/MathCore/Camera.cpp

उम्मीद है कि यह मदद करता है।

Answer 2

मेह कहीं वहां एक तन देखने की उम्मीद कर रहा था।

क्या आप इस लिंक से लिंक कर सकते हैं कि आप कहां से अपना समीकरण प्राप्त कर चुके हैं? (काम पर हूं और वास्तव में खुद को बैठना और इसे प्राप्त करना नहीं चाहते हैं)

आप अपना कैमरा रोटेशन कैसे सेट कर रहे हैं? क्या आप निश्चित हैं कि वहां कुछ भी नहीं चल रहा है?

Answer 3

मैं आपके GetUp विधि में गणित के बारे में कुछ अनिश्चित हूं। क्या आप इसके पीछे गणित पर विस्तार कर सकते हैं?

मेरे लुक कैमरे में मैं अपने अप-वेक्टर को एक बार शुरू करता हूं और फिर उस वेक्टर को क्वाटरनियन का उपयोग करके घुमाता हूं। यह अप वेक्टर की गणना करने के लिए समानांतर वैक्टरों पर एक क्रॉस-उत्पाद करने की कोशिश करने की संभावना को हटा देता है।

कुछ semicode शायद स्पष्ट करने के लिए:

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

यह शायद धीमी है लेकिन एक ही रास्ता मैं के साथ क्या करना जानते हैं 3 डी के लिए रोटेशन मैट्रिक्स के साथ किया जाएगा। Wikipedia Link

कहाँ

और यू = (Camera.position - Camera.lookat) .norm

... अब, मुझे विश्वास है कि आप देना होगा दृश्य मैट्रिक्स का घूर्णन हिस्सा। हालांकि, मैं इस पर 100% नहीं हूँ। मैं अभी भी इस में देख रहा हूँ।

Answer 5

चूंकि मैं पहले से ही उत्तर से संतुष्ट नहीं था, इसलिए मुझे इसे स्वयं समझना पड़ा।

जो मैंने पाया वह वास्तव में काफी सरल है। बस यह करें:

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

"अप" वह दिशा है जो आप चाहते हैं।