मैंने यह प्रश्न पूछने से पहले बहुत कुछ ऑनलाइन पढ़ा है, और मुझे समझ में आया कि व्यू मैट्रिक्स कैमरा ट्रांसफॉर्मेशन मैट्रिक्स का उलटा है। स्पष्टता के लिए, यदि हम कैमरे को एक वास्तविक इकाई के रूप में मानते हैं जो दृश्य में किसी भी अन्य 3D ऑब्जेक्ट की तरह रूपांतरित होता है (इसलिए एक परिवर्तन मैट्रिक्स के साथ, जो पहले अनुवाद करता है, फिर घुमाता है और फिर ऑब्जेक्ट को स्केल करता है) हम कैमरा परिवर्तन प्राप्त करते हैं मैट्रिक्स जिसमें कैमरे की स्थिति होती है। यदि हम इस मैट्रिक्स को उल्टा करते हैं तो हमें व्यू मैट्रिक्स प्राप्त करना चाहिए, लेकिन मेरे कोड में ऐसा नहीं होता है। मेरे पास दो स्थिर विधियां हैं: एक जो स्थिति को देखते हुए परिवर्तन मैट्रिक्स बनाता है, 3 अक्षों का घूर्णन और स्केलिंग का एक मान जो सभी अक्षों पर लागू होता है (पहले अनुवाद करें, फिर घुमाएं, फिर स्केल करें) और दूसरा जो बनाता है कैमरा दिया गया मैट्रिक्स देखें जिसमें एक यॉ (वाई अक्ष का घूर्णन), एक पिच (एक्स अक्ष के चारों ओर घूर्णन) और एक वीईसी 3 है जो स्थिति का प्रतिनिधित्व करता है (यहां हम पहले कैमरे को घुमाते हैं और फिर इसे अपनी नकारात्मक स्थिति के साथ अनुवादित करते हैं, क्योंकि कैमरे को हिलाना उसके चारों ओर की दुनिया को घुमाने के समान है)। यहाँ रूपांतरण मैट्रिक्स के लिए कोड है:

public static Matrix4f createTransformationMatrix(Vector3f translation, float rx, float ry,
        float rz, float scale) {
    
    Matrix4f matrix = new Matrix4f();
    matrix.setIdentity();
    
    Matrix4f.translate(translation, matrix, matrix);
    
    Matrix4f.rotate((float)Math.toRadians(rx), new Vector3f(1, 0, 0), matrix, matrix);
    Matrix4f.rotate((float)Math.toRadians(ry), new Vector3f(0, 1, 0), matrix, matrix);
    Matrix4f.rotate((float)Math.toRadians(rz), new Vector3f(0, 0, 1), matrix, matrix);
    
    Matrix4f.scale(new Vector3f(scale, scale, scale), matrix, matrix);
    
    return matrix;
}

यहाँ दृश्य मैट्रिक्स के लिए कोड है:

public static Matrix4f createViewMatrix(Camera camera) {
    Matrix4f viewMatrix = new Matrix4f();
    viewMatrix.setIdentity();
    
    Matrix4f.rotate((float) Math.toRadians(camera.getPitch()), new Vector3f(1, 0, 0), viewMatrix, viewMatrix);
    Matrix4f.rotate((float) Math.toRadians(camera.getYaw()), new Vector3f(0, 1, 0), viewMatrix, viewMatrix);
    
    Vector3f cameraPos = camera.getPosition();

    Vector3f negativeCameraPos = new Vector3f(-cameraPos.x, -cameraPos.y, -cameraPos.z);
    Matrix4f.translate(negativeCameraPos, viewMatrix, viewMatrix);
    
    return viewMatrix;
}

यहां समस्या आती है: चूंकि मैंने इन दो मैट्रिक्स को बनाने के तरीके पर यूट्यूब पर एक ट्यूटोरियल का पालन किया है और मैंने यह कोड स्वयं नहीं लिखा है, मुझे समझ में नहीं आता कि व्यूमैट्रिक्स कैमरा ट्रांसफॉर्मेशन मैट्रिक्स का उलटा कैसे है। मैंने देखा है कि createViewMatrix() में हम पहले घुमाते हैं और फिर अनुवाद करते हैं (नकारात्मक स्थिति के साथ) जबकि createTransformationMatrix() में हम पहले अनुवाद करते हैं और फिर स्केल घुमाते हैं। तो अगर मैं चीजों को सही ढंग से समझता हूं, तो मैं कैमरा डेटा के साथ एक ट्रांसफॉर्मेशन मैट्रिक्स बना सकता हूं और फिर इसे व्यू मैट्रिक्स प्राप्त करने के लिए उलटा कर सकता हूं, लेकिन यह काम नहीं करता है। मैंने भी कोशिश की, createViewMatrix() में, पहले सकारात्मक स्थिति के साथ अनुवाद करने के लिए (नकारात्मक कैमरापोस की गणना किए बिना) फिर घुमाएं और फिर मैट्रिक्स को घुमाएं। वही परिणाम: यह काम नहीं करता है, जब मैं प्रोग्राम चलाता हूं तो अजीब चीजें होती हैं (मुझे नहीं पता कि उन्हें कैसे समझाया जाए, लेकिन वे गलत हैं)। मैंने कई अन्य चीजों की कोशिश की, लेकिन यह केवल मेरे द्वारा प्रदान किए गए कोड के साथ काम करता है। क्या आप मुझे बता सकते हैं कैसे पहले घूमने और फिर नकारात्मक कैमरा स्थिति के साथ अनुवाद करने से उल्टा कैमरा ट्रांसफ़ॉर्मेशन मैट्रिक्स मिलता है कृपया? मुझे प्रोलिक्सिटी के लिए बहुत खेद है, लेकिन मैं चाहता हूं कि आप पहले शॉट में मेरी समस्या को समझें ताकि आप मुझे जवाब दे सकें। धन्यवाद।

1
Davide Pasero 23 मार्च 2021, 11:28

1 उत्तर

सबसे बढ़िया उत्तर

कैमरा और व्यू मैट्रिक्स के बारे में आपकी बुनियादी समझ सही है। कैमरे का उपयोग आम तौर पर दुनिया में दर्शक / कैमरे की स्थिति और अभिविन्यास का वर्णन करने के लिए किया जाता है, जबकि दृश्य मैट्रिक्स का उपयोग विश्व अंतरिक्ष से अंतरिक्ष को देखने के लिए किया जाएगा, इसलिए यह कैमरा मैट्रिक्स का उलटा होना चाहिए।

ध्यान दें कि मैट्रिक्स गणित में उस क्रम में अंतर होता है जिसमें परिवर्तन लागू होते हैं: घूर्णन और फिर अनुवाद करना अनुवाद और फिर घूर्णन से अलग होता है (हम यहां समीकरण से स्केलिंग छोड़ देंगे क्योंकि आप सामान्य रूप से कैमरे को स्केल नहीं करते हैं - ज़ूमिंग प्रोजेक्शन मैट्रिक्स के माध्यम से किया जाएगा)।

अपने कैमरा मैट्रिक्स का निर्माण करते समय आप पहले कैमरा ओरिएंटेशन सेट करने के लिए घुमाएंगे और फिर कैमरा स्थिति सेट करने के लिए अनुवाद करेंगे, यानी आप कैमरे को 0/0/0 पर बैठे हुए, z अक्ष के साथ देख रहे हैं (इसलिए व्यू वेक्टर होगा 0/ 0/1)। घूमने के बाद आपको एक अलग सामान्यीकृत दृश्य वेक्टर मिलता है लेकिन कैमरा अभी भी 0/0/0 पर "बैठेगा"। फिर आप वास्तविक कैमरा स्थिति में अनुवाद करते हैं (आपको उस स्थिति की गणना करने के लिए अतिरिक्त मैट्रिक्स संचालन की आवश्यकता हो सकती है लेकिन मैं इसे शुरुआत के लिए एक अलग चरण में करूँगा - जब तक कि आप चीजें सही न हों)।

क्या आप मुझे बता सकते हैं कि कैसे पहले घूर्णन और फिर नकारात्मक कैमरा स्थिति के साथ अनुवाद करने से उलटा कैमरा परिवर्तन मैट्रिक्स मिलता है?

ऐसा नहीं होना चाहिए क्योंकि परिणामी दृश्य मैट्रिक्स एक अलग दिशा लागू करेगा। हालांकि "नकारात्मक" रोटेशन (यानी कोण +/- 180 डिग्री) काम करना चाहिए। उस स्थिति में आप कैमरे को इंगित करने के लिए एक वेक्टर घुमाते हैं (इसलिए यदि कैमरा y-अक्ष के चारों ओर 45 डिग्री घुमाता है तो "कैमरे की ओर इशारा करते हुए" किसी भी वस्तु को उसी अक्ष के चारों ओर 225 या -135 डिग्री घुमाने की आवश्यकता होगी)।

नकारात्मक अनुवाद ठीक है क्योंकि यदि आप विश्व अंतरिक्ष में कैमरे को 4/3/2 पर ले जाते हैं तो -4/-3/-2 का अनुवाद विश्व अंतरिक्ष में किसी भी समन्वय को दृश्य स्थान में स्थानांतरित कर देगा।

0
Thomas 23 मार्च 2021, 12:19
धन्यवाद, लेकिन मुझे अभी भी एक और स्पष्टीकरण की आवश्यकता है: जब लोग कहते हैं "(देखें मैट्रिक्स कैमरा ट्रांसफॉर्मेशन मैट्रिक्स है) ^ -1" क्या वे सही हैं? यदि हां, तो क्या मैं कैमरा डेटा का उपयोग करके अपने कोड में createTransformationMatrix() विधि द्वारा यह तथाकथित कैमरा ट्रांसफ़ॉर्मेशन मैट्रिक्स बना सकता हूं, और फिर, व्यूमैट्रिक्स प्राप्त करने के लिए, मैं इसे उलटा कर सकता हूं?
 – 
Davide Pasero
23 मार्च 2021, 12:55
मूल रूप से हाँ। अपनी दुनिया में एक वास्तविक कैमरा ऑब्जेक्ट का उपयोग करने की कल्पना करें: आप इसे किसी अन्य ऑब्जेक्ट की तरह स्थिति और घुमाएंगे। इसलिए किसी भी मैट्रिक्स को बदलने से जो उस वस्तु को स्थानीय स्थान से विश्व स्थान में बदल देता है, उसके परिणामस्वरूप मैट्रिक्स होना चाहिए जो विश्व स्थान से स्थानीय कैमरा स्थान में बदल जाए। (ध्यान दें कि यदि आपका कैमरा किसी अन्य वस्तु से जुड़ा हुआ है तो आपको कैमरे से विश्व स्थान पर जाने के लिए कई मैट्रिक्स को लागू/संयोजन करना पड़ सकता है, लेकिन एक बार आपके पास एक मैट्रिक्स है जो उन सभी का प्रतिनिधित्व करता है जो एक ही उलटा होना पर्याप्त होना चाहिए)।
 – 
Thomas
23 मार्च 2021, 13:08
हां, मैं इसे समझता हूं, लेकिन अगर मैं createTransformationMatrix(camera_data) के माध्यम से कैमरा मैट्रिक्स बनाने का प्रयास करता हूं और फिर मैं इसे उलटा करता हूं तो मुझे createViewMatrix() का उपयोग करने से अलग परिणाम मिलता है, यह कैसे संभव है?
 – 
Davide Pasero
23 मार्च 2021, 13:36
ठीक है, एक के लिए आप अधिक कोणों का उपयोग कर रहे हैं और स्केलिंग जोड़ रहे हैं लेकिन मान लेते हैं कि मान "पहचान" संचालन (rz = 0.0 और scale = 1.0) में परिणाम देते हैं, मैट्रिक्स लगभग समान होना चाहिए (मान सटीकता के कारण थोड़ा भिन्न हो सकते हैं) मुद्दे)। बड़ा अंतर यह है कि createTransformationMatrix() अनुवाद करता है पहले और फिर घूमता है जबकि createViewMatrix() पहले घूमता है - जैसा कि मैंने समझाया कि आदेश प्रासंगिक है (पहले अनुवाद करने का मतलब होगा कि कोई भी बाद का रोटेशन भी स्थिति को घुमाता है )
 – 
Thomas
23 मार्च 2021, 13:40
आप मैट्रिक्स गुणन नियमों पर एक और नज़र डालना चाह सकते हैं। ध्यान दें कि rotate(), translate() और scale() मूल रूप से मैट्रिक्स गुणन में परिणत होते हैं। कार्यान्वयन कुछ शॉर्टकट ले सकता है लेकिन परिणाम अनुवाद, रोटेशन या स्केलिंग मैट्रिक्स बनाने और इसे वर्तमान में गुणा करने जैसा ही होना चाहिए।
 – 
Thomas
23 मार्च 2021, 13:52