ओपन मैट्रिक्स रोटेशन quaternions

Question

इम बारे में x और y अक्ष एक घन के एक सरल रोटेशन करने का प्रयास कर:

मैं चाहता हूँ हमेशा एक राशि एक्स से एक्स अक्ष से अधिक घन बारी बारी से करने और अधिक घन बारी बारी से एक्स अक्ष रोटेशन

पहले की राशि y स्वतंत्र द्वारा yaxis मैं भोलेपन से किया था:

glRotatef(x,1,0,0); 
glRotatef(y,0,1,0); 

तो

लेकिन यह है कि पहली बार घूमता है ov er x फिर y पर घूमता है मैं एक्स एक्सेस के स्वतंत्र रूप से y पर घूमना चाहता हूं।

मैं quaternions में तलाश शुरू कर दी, तो मैं करने की कोशिश की:

Quaternion Rotation1; 
Rotation1.createFromAxisAngle(0,1, 0, globalRotateY); 
Rotation1.normalize(); 

Quaternion Rotation2; 
Rotation2.createFromAxisAngle(1,0, 0, globalRotateX); 
Rotation2.normalize(); 

GLfloat Matrix[16]; 

Quaternion q=Rotation2 * Rotation1; 

q.createMatrix(Matrix); 
glMultMatrixf(Matrix); 

कि अभी लगभग वास्तव में क्या लगातार 2 glRotates कर पूरा किया गया है ... तो मैं im एक कदम या 2.

लापता लगता है quaternions जाने का रास्ता है या मैं कुछ अलग इस्तेमाल कर रहा हूँ? और यदि quaternions जाने का तरीका है तो घन को प्रत्येक धुरी से स्वतंत्र रूप से घूमने के लिए मैं कौन से कदम जोड़ सकता हूं। मुझे लगता है कि किसी और को एक ही मुद्दा है: Rotating OpenGL scene in 2 axes

Answer 1

मुझे यह quaternions का उपयोग कर सही ढंग से काम करने के लिए मिला: मुझे यकीन है कि कुछ अन्य तरीके हैं, लेकिन कुछ शोधकर्ताओं से पहले, यह मेरे लिए पूरी तरह से काम किया। मैंने एक और मंच पर एक समान संस्करण पोस्ट किया।http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=showflat&Number=280859&#Post280859

पहले परिवर्तन के कोण x/y तो प्रत्येक फ्रेम बदलते गुणा एक जमा चार का समुदाय को quaternions कोण का चौका प्रतिनिधित्व बनाने और अंत में है कि चार का समुदाय प्रपत्र मैट्रिक्स वर्तमान मैट्रिक्स गुणा करने के लिए कनवर्ट करें। यहाँ पाश के मुख्य कोड है:

Quaternion3D Rotation1=Quaternion3DMakeWithAxisAndAngle(Vector3DMake(-1.0f,0,0), DEGREES_TO_RADIANS(globalRotateX)); 
Quaternion3DNormalize(&Rotation1); 

Quaternion3D Rotation2=Quaternion3DMakeWithAxisAndAngle(Vector3DMake(0.0f,-1.0f,0), DEGREES_TO_RADIANS(globalRotateY)); 
Quaternion3DNormalize(&Rotation2); 


Matrix3D Mat; 
Matrix3DSetIdentity(Mat); 
Quaternion3DMultiply(&QAccum, &Rotation1); 

Quaternion3DMultiply(&QAccum, &Rotation2); 

Matrix3DSetUsingQuaternion3D(Mat, QAccum); 
globalRotateX=0; 
globalRotateY=0; 

glMultMatrixf(Mat); 

तो घन आकर्षित

Answer 2

यह एक बहुत मदद मिलेगी अगर आप आप क्या करने की कोशिश कर रहा है और रहे हैं की एक अधिक विस्तृत विवरण दे सकता है कि कैसे परिणाम आप हो रही है परिणाम आप चाहते से भिन्न होते हैं। लेकिन सामान्य रूप से घूर्णन के लिए यूलर कोणों का उपयोग करने में कुछ समस्याएं होती हैं, क्योंकि घूर्णन के संयोजन के परिणामस्वरूप अनजान व्यवहार (और सबसे बुरी स्थिति में स्वतंत्रता की डिग्री खोने का परिणाम हो सकता है।)

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

जो पोस्ट आप लिंक करते हैं, उसमें एक और समस्या शामिल है। ऐसा लगता है कि पोस्टर अपनी ऑब्जेक्ट का अनुवाद कर रहा है और फिर उसके घूर्णन कर रहा है, जब उसे पहले घूर्णन करना चाहिए और फिर अनुवाद करना चाहिए।

Answer 3

यह स्पष्ट नहीं है कि आप क्या हासिल करना चाहते हैं। शायद आपको कुछ बिंदुओं के बारे में सोचना चाहिए और जहां आप उन्हें घूमना चाहते हैं - उदा। vertex (1,1,1) मानचित्र (0,1,0) होना चाहिए। फिर, उस जानकारी से, आप आवश्यक रोटेशन की गणना कर सकते हैं।

Quaternions आमतौर पर दो घूर्णन 'पदों' के बीच अंतरण करने के लिए उपयोग किया जाता है। तो चरण एक आपकी शुरुआत और अंत 'स्थिति' की पहचान कर रहा है, जो आपके पास अभी तक नहीं है। एक बार आपके पास हो जाने के बाद, आप अंतरण करने के लिए quaternions का उपयोग करें। ऐसा लगता है कि आपके पास कोई समय-अलग-अलग पहलू नहीं है।

Answer 4

आपकी समस्या जिम्बल लॉक नहीं है। और प्रभावी रूप से, ऐसा कोई कारण नहीं है कि आपका quaternion संस्करण आपके मैट्रिक्स (glRotate) संस्करण से बेहतर काम करेगा क्योंकि आपके द्वारा उपयोग किए जा रहे quaternions गणितीय रूप से आपके घूर्णन matrices के समान हैं।

यदि आप चाहते हैं कि माउस नियंत्रण है, तो आप शायद arcballs देखें।