2012-02-02 13 views
5

जब मैं अभिविन्यास को बदलने की कोशिश करता हूं तो मेरा कैमरा एक बिंदु के चारों ओर घूमता है। अगर मैं अपने कैमरे को घुमाता हूं, तो वाई अक्ष में 30 डिग्री, कैमरे की बजाय 30 डिग्री दाईं ओर देखता है, कैमरा उस बिंदु के चारों ओर घूमता है जिस पर वह देख रहा था।मेरा कैमरा इस गणित के साथ एक बिंदु के चारों ओर घूमता क्यों है?

o is the camera, A and B are 3D models. The lines show line-of-sight. 
This is what I expect: 
    A B 
    | >/
    |/
    |/
    |/ 
    o 

This is what actually happens: 
    A B 
    |\ 
    | \ 
    | \ 
    | > \ 
      o 

अब, मेरी समझ से, क्रम में कैमरा ले जाने के लिए मुझे लगता है कि राशि का प्रतिलोम द्वारा दुनिया बढ़ना है। इसलिए यदि मैं ज़ेड अक्ष में +1 स्थानांतरित करना चाहता हूं तो मैं ज़ेड अक्ष में विश्व -1 का अनुवाद करता हूं। चूंकि मैं उन्मुखता का प्रतिनिधित्व करने के लिए quaternions का उपयोग कर रहा हूँ, मैं कैमरे quaternion के विपरीत का उपयोग करें (क्योंकि उन्मुखता हमेशा इकाई quaternions हैं, मैं उलटा गणना की बजाय conjugate का उपयोग करके अनुकूलित) सही मात्रा से दुनिया घुमाने के लिए।

यहाँ है कि कैसे मैं एक मैट्रिक्स, जहां क्ष उल्टे चार का समुदाय है करने के लिए एक चार का समुदाय कन्वर्ट:

[... ... ... -x] 
|... ... ... -y| 
|... ... ... -z| 
[0  0  0  1] 

और अंत में:

[1 - 2 * (q.y * q.y + q.z * q.z) 2 * (q.x * q.y - q.w * q.z)  2 * (q.x * q.z + q.w * q.y)   0] 
|2 * (q.x * q.y + q.w * q.z)  1 - 2 * (q.x * q.x + q.z * q.z) 2 * (q.y * q.z - q.w * q.x)   0| 
|2 * (q.x * q.z - q.w * q.y)  2 * (q.y * q.z + q.w * q.z)  1 - 2 * (q.x * q.x + q.y * q.y)  0| 
[0         0         0         1] 

उसके बाद, मैं मैट्रिक्स के अनुवाद घटक सेट मैं मॉडल-व्यू मैट्रिक्स स्टैक पर गुणा करता हूं, फिर मेरी सभी ऑब्जेक्ट्स प्रस्तुत करता हूं। मुझे पूरा यकीन है कि यह गणित सही है, लेकिन यह उन परिणामों का उत्पादन नहीं करता है जिनकी मैं अपेक्षा कर रहा था। जाहिर है कि आगे और दाएं वैक्टर समस्याएं हैं, इसलिए मेरा एकमात्र प्रश्न यह है कि वे गलत क्यों हैं और अगर मैं उन परिणामों को प्राप्त करना चाहता हूं, तो उन्हें कैसे सेट किया जाना चाहिए। धन्यवाद।

संपादित करें: मुझे this guy's quaternion camera class से समाधान मिला है। सबसे पहले मैं एक रोटेशन मैट्रिक्स का निर्माण करता हूं जैसे कि मैं पहले कर रहा था, लेकिन फिर मैं पहले, दूसरे और तीसरे कॉलम (xa, ya, और za) से मैट्रिक्स के कॉलम वैक्टर लेता हूं। तब मैं इस तरह मैट्रिक्स के अनुवादकीय घटक सेट:

[... ... ... -xa.dotProduct(cameraPos)] 
|... ... ... -ya.dotProduct(cameraPos)| 
|... ... ... -za.dotProduct(cameraPos)| 
[... ... ... ...      ] 

तब परिणामस्वरूप मैट्रिक्स modelview मैट्रिक्स ढेर पर गुणा किया जा सकता है, और यह पूरी तरह से काम करता है।

+0

अपना संपादन एक समाधान बनाएं और इसे स्वीकार करें। इस तरह हम यहां चारों ओर हल किए गए प्रश्नों को चिह्नित करते हैं। इसके अलावा मुझे लगता है कि आप कुछ स्पष्टीकरण के लायक हैं कि क्या हो रहा है। मैं इसके लिए एक जवाब लिखूंगा। – datenwolf

उत्तर

1

संपादित करें: मुझे इस लड़के के क्वाटरनियन कैमरा वर्ग से समाधान मिला है। सबसे पहले मैं रोटेशन मैट्रिक्स का निर्माण करता हूं जैसे कि मैं पहले कर रहा था, लेकिन फिर मैं पहले, दूसरे और तीसरे कॉलम (xa, ya, और za) से मैट्रिक्स के कॉलम वेक्टर लेता हूं। तब मैं इस तरह मैट्रिक्स की अनुवादकीय घटक सेट:

[... ... ... -xa.dotProduct(cameraPos)] 
|... ... ... -ya.dotProduct(cameraPos)| 
|... ... ... -za.dotProduct(cameraPos)| 
[... ... ... ...      ] 

तब परिणामस्वरूप मैट्रिक्स modelview मैट्रिक्स ढेर पर गुणा किया जा सकता है, और यह पूरी तरह से काम करता है।

हां, यह वही है जो मैंने सुझाव दिया होगा, केवल थोड़ा अलग। आपको समझना होगा कि ओपनजीएल में कैमरा नहीं है, बल्कि इसके बजाय आप दुनिया को विपरीत दिशा में ले जाते हैं, इसलिए आपको उलटा रूपांतरण मैट्रिक्स ढूंढना होगा।

एक कैमरा बस घूमता है और चलता है। यह चीजों को बहुत आसान बनाता है। अनुवाद का विपरीत विपरीत संकेत के साथ एक ही वेक्टर है, और एक रोटेशन मैट्रिक्स के विपरीत यह ट्रांज़ेक्शन (कॉलम और पंक्तियों का आदान-प्रदान) है। अब ओपन की तरह एक समरूप परिवर्तन मैट्रिक्स को देखने के लिए उन्हें का उपयोग करता है:

R t 
0 1 

ऊपरी बाएँ 3 × 3 घूर्णी हिस्सा है, सबसे दायीं ओर का स्तंभ अनुवाद वेक्टर है। मुझे लगता है कि बाकी आप पहले से ही खुद को लगा।

0

ईमानदार होने के लिए, मॉड्यूल-व्यू मैट्रिक्स में गुणा करने के लिए मैट्रिक्स खोजने का प्रयास करना वास्तव में जटिल और बहुत त्रुटि-प्रवण है। बहुत भ्रम और विशेष मामले हैं। उदाहरण के लिए, यदि आप 90 डिग्री ऊपर देख रहे हैं, तो आपकी दो अक्ष एक जैसी हो जाती हैं। एक तार्किक समस्या यह है: यदि आप अपने सिर को वापस घुमा रहे हैं, तो आप शीर्ष बिंदु से गुजरते हैं, आपका अप वेक्टर उलटा होना चाहिए, है ना? लेकिन अगर आप इसे 0.0001 डिग्री से चूक जाते हैं तो क्या होगा? तो आपको उस बिंदु के चारों ओर अपने सिर को चालू करना चाहिए ताकि आपका ऊपर वेक्टर अभी भी ऊपर हो।

मेरी राय में, किसी अन्य परिप्रेक्ष्य से समस्या का समाधान करने का सबसे अच्छा तरीका है। के दो मामलों मान लेते हैं:

    उल्टा पुल्टा असंभव
  • :
    • दिशा के लिए अपने कैमरे स्थान और अक्षांश/देशांतर के लिए एक बिंदु रखें। सरल पाप/कॉस ऑपरेशंस के साथ आप एक दिशा वेक्टर प्राप्त कर सकते हैं। कैमरा स्थान इसके अलावा
      • , दोनों ऊपर और लक्ष्य वैक्टर रखें: आपका अप वेक्टर (0, 1, 0)
      • टर्निंग अक्षांश और देशांतर
    • उल्टा पुल्टा संभव
    • बदल रहा है है।
    • मोड़ते समय, सही = लक्ष्य x की गणना करें और फिर x * दाएं + y * ऊपर
    • पर लक्ष्य बदलें, फिर आपको लक्ष्य वेक्टर को सामान्य करने और नए की गणना करने की आवश्यकता है। हालांकि को संभालने के लिए बहुत सारे मामले हैं।

इन सब के बाद, आप बस gluLookAt कहते हैं।

+0

"ईमानदार होने के लिए, मॉड्यूल-व्यू मैट्रिक्स में गुणा करने के लिए मैट्रिक्स खोजने का प्रयास करना वास्तव में जटिल और बहुत त्रुटि-प्रवण है।" नहीं यह नहीं। सापेक्ष समन्वय उन्मुखताओं के बारे में सोचने के लिए Matrices सबसे कठिन तरीका है। पहले 3 कॉलम में से प्रत्येक ट्रांसफॉर्म किए गए समन्वय प्रणाली के मूल वैक्टरों में से एक है। चौथा कॉलम सापेक्ष अनुवाद है। दृश्य और लक्ष्य वैक्टर से कैमरा मैट्रिक लिखना कहीं आसान है, फिर उस त्रिकोणमिति के बीच में। – datenwolf

+0

मुझे पता है कि। मैं जो कह रहा हूं वह यह है कि, उदाहरण के लिए यदि आपके पास अगले फ्रेम तक 3 अलग-अलग प्रकार के आंदोलन (कहते हैं, हिलें, मोड़ें और रोल करें), स्थिति/अक्षांश/देशांतर के साथ ऐसा करना बहुत आसान है और अंत में इसे मैट्रिक्स में परिवर्तित करना, पिछले एक के मैट्रिक्स में प्रत्येक ऑपरेशन को लागू करने की कोशिश करने के बजाय। – Shahbaz

संबंधित मुद्दे