कैमरा पिच सीमित करें

Question

जब मैं केवल कैमरा quaternion है मैं कैमरे पिच को कुशलता से कैसे सीमित कर सकता हूं? क्या मुझे यूलर कोणों में परिवर्तित करना है और फिर वापस quaternion या क्या कोई और तरीका है?

vector A = [x, y, z] 
Q.x = A.x * sin(theta/2) 
Q.y = A.y * sin(theta/2) 
Q.z = A.z * sin(theta/2) 
Q.w = cos(theta/2) 

कहाँ एक स्थिति है और थीटा कोण आप कैमरा बारी बारी से (पिच को समायोजित) करना चाहते हैं:

Answer 1

कैमरा रोटेशन quaternions रूप में परिभाषित किया जा सकता है।

तो यदि आपके पास क्वाटरनियन उपलब्ध है तो आप प्रत्येक बार सत्यापित करके पिच के कोण को सीमित कर सकते हैं यदि रोटेशन कोण प्लस/शून्य वास्तविक कोण ठीक है।

मुझे लगता है कि अगर आप के रूप में

+cos(supLim/2) < (Q.w + P.w) < -cos(infLim/2) 

अपने सीमा तय कोज्या एक सतत समारोह इस काम करने के लिए माना जाता है है के रूप में आप रूपांतरण से बच सकते हैं।

यदि आप कोड पोस्ट कर सकते हैं तो आप वास्तव में उपयोग कर रहे हैं शायद हम थोड़ा और मदद कर सकते हैं।

Answer 2

पिच पूर्ण घूर्णन का केवल एक घटक है, इसलिए यदि आप इस तरह के घूर्णन के बारे में सोचना चाहते हैं, तो आप बेहतर ढंग से पिल्ले को स्टोर कर सकते हैं, संभवतः यूलर कोण का उपयोग कर।

बस यूलर कोणों में कनवर्ट करना और जब आपको आंदोलन को सीमित करने की आवश्यकता होती है तो वह बहुत अच्छी तरह से काम नहीं कर सकता है, क्योंकि आपको अंतिम फ्रेम (यदि आपके पास है) को याद रखने की आवश्यकता है, तो यह देखने के लिए कि क्या आप सीमा पारित कर चुके हैं, और कौन सी दिशा।

जैसा कि मैंने इसे देखा, quaternions का मुख्य बिंदु यह है कि आपको इस तरह की सीमाओं से परेशान करने की आवश्यकता नहीं है। सब कुछ बिना किसी एकवचन के काम करता है। आप पिच को सीमित क्यों करना चाहते हैं?

Answer 3

यदि कैमरे में कभी भी कोई रोल नहीं है (जैसा कि बहुत से गेम में आम है, जैसे कि पहले व्यक्ति निशानेबाजों), तो समाधान सरल है। यदि रोल है, तो इसमें एक अतिरिक्त कदम शामिल है। यदि कोई रोल नहीं है, तो मैं क्या करूँगा इसके साथ शुरू करूंगा, और यदि समाधान हो तो समाधान करने के लिए सामान्यीकरण करें।

क्यूसी कैमरा रोटेशन होने दें। Qy के रूप में एक ही yaw के साथ एक रोटेशन qy, लेकिन शून्य पिच के साथ चलो।

qc = qp * qy 

हम QC के लिए QY से रोटेशन के रूप में पिच रोटेशन QP ठीक हो सकता है:

qp = qc * qy^-1 

चाल अगर कोई रोल है, कैमरा रोटेशन एक विचलन रोटेशन एक पिच रोटेशन के बाद है , तो, qy का निर्माण करना है, इसलिए हम इसे qp के लिए हल करने के लिए उपर्युक्त समीकरण में प्लग कर सकते हैं। वीसी को कैमरे के लेंस, या "फॉरवर्ड वेक्टर" से इंगित यूनिट वेक्टर बनने दें। वही वेक्टर हो, लेकिन क्षैतिज विमान और सामान्यीकृत के लिए प्रक्षेपित किया। आखिरकार, v0 को आगे बढ़ने दें जब कैमरा रोटेशन क्यूसी पहचान रोटेशन है। घुमावदार v0 में घुमावदार घूर्णन यौ रोटेशन है।

yaw = asin(Norm(cross(v0, vy))) 

इसी विचलन रोटेशन है: के रूप में कोण दिया जा सकता है

qy = { cos(yaw/2), up * sin(yaw/2) } 

कहाँ "ऊपर" अप दिशा में इकाई वेक्टर, विचलन रोटेशन के लिए अक्ष उर्फ ​​है। पिच quaternion qp पाने के लिए इसे qp = qy^-1 * qc में प्लग करें।अंत में, QP से पिच कोण के रूप में:

pitch = 2*asin(Dot(right, [qp[1], qp[2], qp[3]])) 

कहाँ "सही", सही दिशा में इकाई वेक्टर है पिच रोटेशन के लिए अक्ष उर्फ।

जैसा कि मैंने कहा, कैमरा भी रोल होने पर चीजें अधिक जटिल हो जाती हैं, लेकिन सामान्य रणनीति समान होती है। आप घूर्णन घटकों के उत्पाद के रूप में कैमरे के घूर्णन को तैयार करते हैं, फिर इच्छित घटक को अलग करें (इस मामले में, पिच)।

qc = qr * qp * qy 

हम एक चर qx परिभाषित कर सकते हैं संयुक्त पिच और रोल रोटेशन होने के लिए: उदाहरण के लिए, यदि यूलर अनुक्रम आप "पिच" को परिभाषित करने के लिए उपयोग आम विचलन पिच रोल अनुक्रम है, तो आप qc के रूप में परिभाषित :

qc = qx * qy 

हम पहले से ही इस रूप में qx के लिए हल करने के लिए कैसे पता है, कदम हम इसके बाद के संस्करण का इस्तेमाल किया QP के लिए हल करने के लिए retracing द्वारा:

qx = qr * qp 

अब हम QC के रूप में लिख सकते हैं। qx के लिए परिभाषा उलटफेर करने पर हम पाते हैं:

qp = qr^-1 * qx 

हम सिर्फ qx के लिए हल है, तो पिच रोटेशन QP के लिए हल करने के लिए, हम केवल रोल qr की जरूरत है। हम वैक्टरों का उपयोग करके इसे बना सकते हैं जैसा हमने पहले किया था। वीसी को फिर से आगे वेक्टर बनने दें। रोल इस वेक्टर के चारों ओर घूर्णन होगा। वी कैमरे के ऊपर वेक्टर (विश्व निर्देशांक में) होने दें, और vu0 को शून्य रोल के साथ कैमरे के ऊपर वेक्टर बनने दें। हम वैश्विक अप वेक्टर को वीसी के लंबवत विमान में प्रक्षेपित करके vu0 बना सकते हैं, फिर सामान्यीकृत कर सकते हैं। रोल रोटेशन क्यूआर फिर vu0 से vu तक घूर्णन होता है। इस घूर्णन की धुरी आगे वेक्टर वीसी है। रोल कोण है

roll = asin(Dot(vc, cross(vu0, vu))) 

इसी चौका है:

qr = { cos(roll/2), forward * sin(roll/2) } 

कहाँ "आगे" रोल रोटेशन की धुरी है।

Answer 4

मैं पार्टी के लिए देर से एक छोटे से हो सकता है, लेकिन यह मैं कैसे इसे हल है:

 // "Up" = local vector -> rotation * Vector3.UnitY 
     // "Forward" = local vector -> rotation * Vector3.UnitZ 
     // "Right" = local vector -> rotation * Vector3.UnitX 

    public void Rotate(Vector3 axis, float angle) 
    { 
     if (LerpRotation) 
     { 
      RotationTarget *= Quaternion.FromAxisAngle(axis, angle); 
     } 
     else 
     { 
      Rotation *= Quaternion.FromAxisAngle(axis, angle); 
     } 
     //Locking the Pitch in 180° 
     float a = Vector3.CalculateAngle(Vector3.UnitY, Up); 
     float sign = Math.Sign(Forward.Y); 
     float delta = (float)Math.PI/2 - a; 
     if(delta < 0) 
      Rotation *= Quaternion.FromAxisAngle(Right, delta * sign); 
    }