जीएलएसएल और जीएलएम के बीच मैट्रिक्स गणित के साथ असंगतता, या "खराब" दृश्य मैट्रिक्स

Question

जैसी कोई चीज है, इसलिए, मैं जीएलएसएल और जीएलएम के बीच कुछ विषमताओं में आया हूं।

अगर मैं निम्न दृश्य मैट्रिक्स (C++) उत्पन्न:

vec3 pos(4, 1, 1); 
vec3 dir(1, 0, 0); 
mat4 viewMat = glm::lookAt(pos, pos+dir, vec3(0,0,1)); 

और फिर, GLSL में, कार्य करें:

fragColour.rgb = vec3(inverse(viewMat) * vec4(0,0,0,1))/4.f; 

तो मैं स्क्रीन गुलाबी-लाल बनने के लिए उम्मीद, या (1.0,0.25,0.25)। इसके बजाय, मुझे काला मिलता है।

अगर मैं GLM में ऐसा करते हैं, तथापि:

vec3 colour = vec3(glm::inverse(viewMat) * vec4(0,0,0,1))/4.f; 
cout << glm::to_string(colour) << endl; 

मैं (1.0,0.25,0.25) का परिणाम उम्मीद मिलता है।

अब, अगर मैं viewMat बदलने के बजाय होने के लिए (C++):

vec3 pos(4, 1, 1); 
vec3 dir(1, 0.000001, 0); 
mat4 viewMat = glm::lookAt(pos, pos+dir, vec3(0,0,1)); 

फिर

bam! मुझे जीएलएसएल और जीएलएम दोनों में (1.0,0.25,0.25) मिलता है।

इससे मुझे कोई समझ नहीं आता है। यह ऐसा क्यों करता है? यह दृश्य मैट्रिक्स जीएलएसएल में हर जगह ठीक काम करता है - मैं बस इसे उलटा नहीं कर सकता। ऐसा होता है जब भी dirY == 0.f।

इसके अलावा, कृपया प्रश्न शीर्षक के लिए सुधार का सुझाव दें, मुझे यकीन नहीं है कि यह क्या होना चाहिए।

संपादित करें: इसके अलावा, ऐसा लगता है कि यह ऊपर की ओर वेक्टर (जिसे मैं वैसे भी ज़ेड पर सेट करता हूं) के साथ कुछ भी नहीं करना प्रतीत होता है। यहां तक ​​कि अगर मैं (0,1,0) तक सेट करता हूं, वही होता है। सबकुछ किनारे पर जाता है, लेकिन मैं अभी भी जीएलएसएल में दृश्य मैट्रिक्स को उलटा नहीं कर सकता।

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

Answer 1

मनमानी 4x4 मैट्रिक्स उलट GPU पक्ष पर कम एफपीयू सटीकता और उलट दौरान कई डिवीजनों की जरूरत जैसे कई कारणों के लिए एक तेज़ और सुरक्षित कार्य

नहीं है (अच्छी तरह से यह गणना की विधि पर निर्भर करता है), और सभी matrices विपरीत नहीं है (मुझे लगता है कि जीएल के पास ऐसा कोई कार्यान्वयन नहीं है) ... इस पर बेहतर छवि के लिए Understanding 4x4 homogenous transform matrices देखें और matrix_inv देखें कि गणना वास्तव में कितनी जटिल है (यह निर्धारक का उपयोग करती है) । जीईएम (गॉस उन्मूलन विधि) भी है, लेकिन इसकी क्विर्क और पंक्तियों को सॉर्ट करने की आवश्यकता के कारण इसका उपयोग नहीं किया जाता है ...

यदि मैट्रिस स्थिर प्रति फ्रेम रेंडर हैं जो आमतौर पर यह है कि यह GPU शक्ति का अपशिष्ट है वेरटेक्स/फ्रैगमेंट/ज्यामिति शेडर्स में प्रत्येक वर्टेक्स/फ्रैगमेंट प्रति बार बार-बार कंप्यूटिंग (यही कारण है कि गति वृद्धि वहां है)।

किसी का विरोध कर सकता है कि orthogonal homogenous matrix उलट सिर्फ मैट्रिक्स transposing है, लेकिन कैसे जीएल/GLSL जान सकता है कि यह इस तरह के मैट्रिक्स के साथ संबंधित वैसे भी उस मामले में (जाँच नहीं कि सरल या तो है) आप transpose जिसमें कार्यान्वित किया जाता है का उपयोग कर सकते जीएलएसएल और तेजी से होना चाहिए (यह केवल तत्वों की पुनरावृत्ति है)