🍿 🤵🏼 👩🏿‍🔧 गामेदेव में मठ सरल है। मैट्रिसेस और अफाइन ट्रांसफॉर्मेशन 👨🏾‍🏫 💆🏻 🕹️

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

आइए लेख के संदर्भ में सबसे महत्वपूर्ण अवधारणाओं में से एक के साथ शुरू करते हैं - रूपांतरण को प्रभावित करें । एफ़िन ट्रांसफ़ॉर्मेशन , संक्षेप में, एक विशेष मैट्रिक्स द्वारा वेक्टर को गुणा करके समन्वय प्रणाली (या स्थान) का परिवर्तन है। उदाहरण के लिए, ट्रांसफ़ॉर्मेशन जैसे कि मूवमेंट, रोटेशन, स्केलिंग, रिफ्लेक्शन, आदि। एफाइन ट्रांसफ़ॉर्मेशन का मुख्य गुण यह है कि आप एक ही स्थान पर रहते हैं (द्वि-आयामी सदिश से द्वि-आयामी सदिश बनाना असंभव है) और यह कि यदि रेखाएँ एक दूसरे के समांतर हों / समानांतर हों / रूपांतरण से पहले पार किए गए थे, फिर इस संपत्ति को रूपांतरण के बाद संरक्षित किया जाएगा। इसके अलावा, उनके पास बहुत सारे गणितीय गुण हैं जिनके लिए समूहों, सेटों और रैखिक बीजगणित के सिद्धांत के ज्ञान की आवश्यकता होती है, जिससे उनके साथ काम करना आसान हो जाता है।

टीआरएस मैट्रिक्स

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

जहां:
चाल टी = नया वेक्टर 3 (डी, एच, एल) है।
स्केलिंग - s = नया वेक्टर 3 (नया वेक्टर 3 (ए, ई, आई)। मैग्निट्यूड, नया वेक्टर 3 (बी, एफ, जे)। मैग्निट्यूड, नया वेक्टर 3 (सी, जी, के)। मैग्नमिट्यूड)।

एक घुमाव फॉर्म का एक मैट्रिक्स है:

अब आइए एकता के संदर्भ में थोड़ा गहराई से जाएं। शुरुआत करने के लिए, टीआरएस मैट्रिक्स एक बहुत सुविधाजनक चीज है, लेकिन इसका उपयोग हर जगह नहीं किया जाना चाहिए। चूंकि एक इकाई में वैक्टर की स्थिति या जोड़ का एक सरल संकेत तेजी से काम करेगा, लेकिन कई गणितीय एल्गोरिदम में, वैक्टर वैक्टर की तुलना में कई गुना अधिक सुविधाजनक हैं। एकता में TRS कार्यक्षमता मोटे तौर पर मैट्रिक्स 4x4 वर्ग में लागू की गई है, लेकिन यह आवेदन के दृष्टिकोण से सुविधाजनक नहीं है। चूंकि, गुणा के माध्यम से मैट्रिक्स को लागू करने के अलावा, यह आम तौर पर ऑब्जेक्ट के ओरिएंटेशन पर जानकारी स्टोर कर सकता है, और कुछ परिवर्तनों के लिए, मैं न केवल स्थिति की गणना करने में सक्षम होना चाहता हूं, बल्कि ऑब्जेक्ट के ओरिएंटेशन को समग्र रूप से भी बदल सकता है (उदाहरण के लिए, प्रतिबिंब जो एकता में लागू नहीं है)

स्थानीय समन्वय प्रणाली के लिए सभी उदाहरण नीचे दिए गए हैं (GameObject की उत्पत्ति को निर्देशांक की उत्पत्ति माना जाता है, जिसके अंदर ऑब्जेक्ट स्थित है। यदि ऑब्जेक्ट इकाई में पदानुक्रम की जड़ है, तो मूल दुनिया है (0,0,0))।

टीआरएस मैट्रिक्स का उपयोग करने के बाद से हम मूल रूप से अंतरिक्ष में किसी वस्तु की स्थिति का वर्णन कर सकते हैं, हमें टीआरएस से स्थिति के विशिष्ट मूल्यों, रोटेशन और एकता के लिए पैमाने पर अपघटन की आवश्यकता है। ऐसा करने के लिए, आप मैट्रिक्स 4x4 वर्ग के लिए विस्तार विधियाँ लिख सकते हैं

स्थिति, रोटेशन और स्केल प्राप्त करना

public static Vector3 ExtractPosition(this Matrix4x4 matrix) { Vector3 position; position.x = matrix.m03; position.y = matrix.m13; position.z = matrix.m23; return position; } public static Quaternion ExtractRotation(this Matrix4x4 matrix) { Vector3 forward; forward.x = matrix.m02; forward.y = matrix.m12; forward.z = matrix.m22; Vector3 upwards; upwards.x = matrix.m01; upwards.y = matrix.m11; upwards.z = matrix.m21; return Quaternion.LookRotation(forward, upwards); } public static Vector3 ExtractScale(this Matrix4x4 matrix) { Vector3 scale; scale.x = new Vector4(matrix.m00, matrix.m10, matrix.m20, matrix.m30).magnitude; scale.y = new Vector4(matrix.m01, matrix.m11, matrix.m21, matrix.m31).magnitude; scale.z = new Vector4(matrix.m02, matrix.m12, matrix.m22, matrix.m32).magnitude; return scale; }

इसके अलावा, सुविधाजनक काम के लिए, आप इसमें TRS के साथ काम करने के लिए ट्रांसफ़ॉर्म क्लास एक्सटेंशन के एक जोड़े को लागू कर सकते हैं।

विस्तार परिवर्तन

 public static void ApplyLocalTRS(this Transform tr, Matrix4x4 trs) { tr.localPosition = trs.ExtractPosition(); tr.localRotation = trs.ExtractRotation(); tr.localScale = trs.ExtractScale(); } public static Matrix4x4 ExtractLocalTRS(this Transform tr) { return Matrix4x4.TRS(tr.localPosition, tr.localRotation, tr.localScale); }

इस पर, एकता के लाभ समाप्त हो जाते हैं, क्योंकि एकता में मेट्रिक्स ऑपरेशन में बहुत खराब हैं। कई एल्गोरिदम को मैट्रिक्स अंकगणित की आवश्यकता होती है, जो पूरी तरह से बुनियादी संचालन में भी इकाई में लागू नहीं होती है, जैसे कि मैट्रिसेस जोड़ना और एक स्केलर द्वारा मैट्रिसेस को गुणा करना। इसके अलावा, यूनिटी 3 डी में वैक्टर के कार्यान्वयन की ख़ासियत के कारण, इस तथ्य से जुड़ी कई असुविधाएं भी हैं कि आप 4x4 वेक्टर बना सकते हैं, लेकिन बॉक्स से बाहर 1x4 नहीं बना सकते। चूंकि हम प्रतिबिंब के लिए हाउसहोल्डर के परिवर्तन के बारे में अधिक बात करेंगे, इसलिए हम पहले इसके लिए आवश्यक संचालन को लागू करते हैं।

स्केलर द्वारा जोड़ना / घटाना और गुणा करना सरल है। यह बल्कि भारी दिखता है, लेकिन यहां कुछ भी जटिल नहीं है, क्योंकि अंकगणित सरल है।

बुनियादी मैट्रिक्स ऑपरेशन

 public static Matrix4x4 MutiplyByNumber(this Matrix4x4 matrix, float number) { return new Matrix4x4( new Vector4(matrix.m00 * number, matrix.m10 * number, matrix.m20 * number, matrix.m30 * number), new Vector4(matrix.m01 * number, matrix.m11 * number, matrix.m21 * number, matrix.m31 * number), new Vector4(matrix.m02 * number, matrix.m12 * number, matrix.m22 * number, matrix.m32 * number), new Vector4(matrix.m03 * number, matrix.m13 * number, matrix.m23 * number, matrix.m33 * number) ); } public static Matrix4x4 DivideByNumber(this Matrix4x4 matrix, float number) { return new Matrix4x4( new Vector4(matrix.m00 / number, matrix.m10 / number, matrix.m20 / number, matrix.m30 / number), new Vector4(matrix.m01 / number, matrix.m11 / number, matrix.m21 / number, matrix.m31 / number), new Vector4(matrix.m02 / number, matrix.m12 / number, matrix.m22 / number, matrix.m32 / number), new Vector4(matrix.m03 / number, matrix.m13 / number, matrix.m23 / number, matrix.m33 / number) ); } public static Matrix4x4 Plus(this Matrix4x4 matrix, Matrix4x4 matrixToAdding) { return new Matrix4x4( new Vector4(matrix.m00 + matrixToAdding.m00, matrix.m10 + matrixToAdding.m10, matrix.m20 + matrixToAdding.m20, matrix.m30 + matrixToAdding.m30), new Vector4(matrix.m01 + matrixToAdding.m01, matrix.m11 + matrixToAdding.m11, matrix.m21 + matrixToAdding.m21, matrix.m31 + matrixToAdding.m31), new Vector4(matrix.m02 + matrixToAdding.m02, matrix.m12 + matrixToAdding.m12, matrix.m22 + matrixToAdding.m22, matrix.m32 + matrixToAdding.m32), new Vector4(matrix.m03 + matrixToAdding.m03, matrix.m13 + matrixToAdding.m13, matrix.m23 + matrixToAdding.m23, matrix.m33 + matrixToAdding.m33) ); } public static Matrix4x4 Minus(this Matrix4x4 matrix, Matrix4x4 matrixToMinus) { return new Matrix4x4( new Vector4(matrix.m00 - matrixToMinus.m00, matrix.m10 - matrixToMinus.m10, matrix.m20 - matrixToMinus.m20, matrix.m30 - matrixToMinus.m30), new Vector4(matrix.m01 - matrixToMinus.m01, matrix.m11 - matrixToMinus.m11, matrix.m21 - matrixToMinus.m21, matrix.m31 - matrixToMinus.m31), new Vector4(matrix.m02 - matrixToMinus.m02, matrix.m12 - matrixToMinus.m12, matrix.m22 - matrixToMinus.m22, matrix.m32 - matrixToMinus.m32), new Vector4(matrix.m03 - matrixToMinus.m03, matrix.m13 - matrixToMinus.m13, matrix.m23 - matrixToMinus.m23, matrix.m33 - matrixToMinus.m33) ); }

लेकिन प्रतिबिंब के लिए, हमें किसी विशेष मामले में मैट्रिक्स गुणन के संचालन की आवश्यकता होती है। 1x4 द्वारा आयाम 4x4 के एक वेक्टर का गुणन (ट्रांसपोज़्ड) यदि आप मैट्रिक्स गणित से परिचित हैं, तो आप जानते हैं कि इस गुणा के साथ आपको आयाम की चरम संख्याओं को देखने की आवश्यकता है, और आपको आउटपुट पर मैट्रिक्स का आयाम मिलेगा, अर्थात इस मामले में 4x4। मैट्रिस को कैसे गुणा किया जाता है, इस पर पर्याप्त जानकारी है, इसलिए हम इसे पेंट नहीं करेंगे। यहां एक विशिष्ट मामले का उदाहरण दिया गया है जो भविष्य में काम आएगा।

एक सदिश द्वारा एक सदिश गुणा करें

 public static Matrix4x4 MultiplyVectorsTransposed(Vector4 vector, Vector4 transposeVector) { float[] vectorPoints = new[] {vector.x, vector.y, vector.z, vector.w}, transposedVectorPoints = new[] {transposeVector.x, transposeVector.y, transposeVector.z, transposeVector.w}; int matrixDimension = vectorPoints.Length; float[] values = new float[matrixDimension * matrixDimension]; for (int i = 0; i < matrixDimension; i++) { for (int j = 0; j < matrixDimension; j++) { values[i + j * matrixDimension] = vectorPoints[i] * transposedVectorPoints[j]; } } return new Matrix4x4( new Vector4(values[0], values[1], values[2], values[3]), new Vector4(values[4], values[5], values[6], values[7]), new Vector4(values[8], values[9], values[10], values[11]), new Vector4(values[12], values[13], values[14], values[15]) ); }

गृहस्थ परिवर्तन

किसी भी धुरी के सापेक्ष किसी वस्तु को कैसे प्रतिबिंबित किया जाए, इसकी तलाश में, मैं अक्सर आवश्यक दिशा में नकारात्मक पैमाने डालने की सलाह देता हूं। यूनिटी के संदर्भ में यह बहुत बुरी सलाह है, क्योंकि यह इंजन में बहुत सारे सिस्टम (ब्रेकिंग, टकराव, आदि) को तोड़ता है। कुछ एल्गोरिदम में, यह काफी गैर-तुच्छ गणना में बदल जाता है, अगर आपको वेक्टर 3.up या वेक्टर3.forward के संबंध में तुच्छ नहीं प्रतिबिंबित करने की आवश्यकता है। लेकिन एक मनमाना दिशा में। बॉक्स से बाहर एक इकाई में प्रतिबिंब की विधि को लागू नहीं किया जाता है, इसलिए मैंने हाउसहोल्डर विधि को लागू किया ।

हाउसहोल्डर परिवर्तन का उपयोग न केवल कंप्यूटर ग्राफिक्स में किया जाता है, बल्कि इस संदर्भ में यह एक रैखिक परिवर्तन है जो एक विमान के सापेक्ष एक वस्तु को दर्शाता है जो "मूल" से होकर गुजरता है और विमान के सामान्य से निर्धारित होता है। कई स्रोतों में, यह काफी जटिल और स्पष्ट रूप से वर्णित है, हालांकि इसका सूत्र प्राथमिक है।

H = I-2 * n * (n ^ T)

जहां H परिवर्तनकारी मैट्रिक्स है, I हमारे मामले में Matrix4x4.identity है, और n = new Vector4 (planeNormal.x, planeNormal.y, planeNormal.z, 0)। प्रतीक T का अर्थ है ट्रांसपोज़िशन, अर्थात n * (n ^ T) गुणा करने के बाद हमें 4x4 मैट्रिक्स मिलता है।

लागू किए गए तरीके काम आएंगे और रिकॉर्डिंग बहुत कॉम्पैक्ट होगी।

गृहस्थ परिवर्तन

 public static Matrix4x4 HouseholderReflection(this Matrix4x4 matrix4X4, Vector3 planeNormal) { planeNormal.Normalize(); Vector4 planeNormal4 = new Vector4(planeNormal.x, planeNormal.y, planeNormal.z, 0); Matrix4x4 householderMatrix = Matrix4x4.identity.Minus( MultiplyVectorsTransposed(planeNormal4, planeNormal4).MutiplyByNumber(2)); return householderMatrix * matrix4X4; }

महत्वपूर्ण: प्लेन नॉर्मल को सामान्य किया जाना चाहिए (जो तार्किक है), और अंतिम समन्वय एन 0 होना चाहिए, ताकि दिशा में खिंचाव का कोई प्रभाव न हो, क्योंकि यह वेक्टर एन की लंबाई पर निर्भर करता है।

अब एकता में सुविधा के लिए हम परिवर्तन के लिए विस्तार विधि को लागू करते हैं

स्थानीय समन्वय प्रणाली में परावर्तन परिवर्तन

 public static void LocalReflect(this Transform tr, Vector3 planeNormal) { var trs = tr.ExtractLocalTRS(); var reflected = trs.HouseholderReflection(planeNormal); tr.ApplyLocalTRS(reflected); }

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

आपका ध्यान के लिए धन्यवाद!

गामेदेव में मठ सरल है। मैट्रिसेस और अफाइन ट्रांसफॉर्मेशन

टीआरएस मैट्रिक्स

गृहस्थ परिवर्तन

More articles: