RenderScript मैट्रिक्स फ़ंक्शन

खास जानकारी

इन फ़ंक्शन की मदद से, 2x2, 3x3, और 4x4 रैंक वाले स्क्वेयर मैट्रिक्स में बदलाव किया जा सकता है. ये खास तौर पर ग्राफ़िक ट्रांसफ़ॉर्मेशन के लिए काम के होते हैं और ये OpenGL के साथ काम करते हैं.

हम पंक्तियों और कॉलम के लिए, शून्य पर आधारित इंडेक्स का इस्तेमाल करते हैं. उदाहरण के लिए, rs_matrix4x4 का आखिरी एलिमेंट (3, 3) पर मिलता है.

RenderScript, कॉलम-मेजर मैट्रिक्स और कॉलम-आधारित वैक्टर का इस्तेमाल करता है. किसी वेक्टर को बदलने के लिए, वेक्टर के बाद में गुणा किया जाता है. जैसे, (matrix * vector), जैसा कि rsMatrixMultiply() में दिया गया है.

एक साथ दो ट्रांसफ़ॉर्मेशन करने वाली ट्रांसफ़ॉर्मेशन मैट्रिक बनाने के लिए, दो सोर्स मैट्रिक को गुणा करें. पहला ट्रांसफ़ॉर्मेशन, दाईं ओर दिए गए आर्ग्युमेंट के तौर पर इस्तेमाल करें. उदाहरण के लिए, ऐसा ट्रांसफ़ॉर्मेशन मैट्रिक बनाने के लिए जो ट्रांसफ़ॉर्मेशन s1 के बाद s2 लागू करता है, rsMatrixLoadMultiply(&combined, &s2, &s1) को कॉल करें. यह s2 * (s1 * v) से लिया गया है, जो (s2 * s1) * v है.

ट्रांसफ़ॉर्मेशन मैट्रिक बनाने के लिए, हमारे पास दो तरह के फ़ंक्शन हैं: rsMatrixLoadTransformation और rsMatrixTransformation. पहले स्टाइल में, ट्रांसफ़ॉर्मेशन मैट्रिक को पहले आर्ग्युमेंट में ही सेव किया जाता है. बाद वाला, पहले से मौजूद ट्रांसफ़ॉर्मेशन मैट्रिक में बदलाव करता है, ताकि नया ट्रांसफ़ॉर्मेशन पहले हो सके. उदाहरण के लिए, अगर किसी ऐसे मैट्रिक पर rsMatrixTranslate() को कॉल किया जाता है जो पहले से ही स्केलिंग करता है, तो वेक्टर पर लागू होने पर, नतीजा देने वाला मैट्रिक पहले ट्रांसलेशन करेगा और फिर स्केलिंग करेगा.

खास जानकारी

फ़ंक्शन
rsExtractFrustumPlanes फ़्रस्टम प्लेन का हिसाब लगाना
rsIsSphereInFrustum यह जांचता है कि कोई गोला, फ़्रस्टम प्लेन के अंदर है या नहीं
rsMatrixGet एक एलिमेंट पाना
rsMatrixInverse मैट्रिक्स को बदले बिना उसका इन्वर्स बनाता है
rsMatrixInverseTranspose मैट्रिक्स को इनवर्स और ट्रांसपोज़ करता है
rsMatrixLoad कोई मैट्रिक लोड करना या कॉपी करना
rsMatrixLoadFrustum फ़्रस्टम प्रोजेक्शन मैट्रिक्स लोड करना
rsMatrixLoadIdentity आइडेंटिटी मैट्रिक लोड करना
rsMatrixLoadMultiply दो मैट्रिक्स को गुणा करना
rsMatrixLoadOrtho ऑर्थोग्राफ़िक प्रोजेक्शन मैट्रिक्स लोड करना
rsMatrixLoadPerspective पर्सपेक्टिव प्रोजेक्शन मैट्रिक लोड करना
rsMatrixLoadRotate रोटेशन मैट्रिक्स लोड करना
rsMatrixLoadScale स्केलिंग मैट्रिक लोड करना
rsMatrixLoadTranslate अनुवाद मैट्रिक्स लोड करना
rsMatrixMultiply किसी मैट्रिक्स को वेक्टर या किसी अन्य मैट्रिक्स से गुणा करना
rsMatrixRotate ट्रांसफ़ॉर्मेशन मैट्रिक्स पर रोटेशन लागू करना
rsMatrixScale ट्रांसफ़ॉर्मेशन मैट्रिक में स्केलिंग लागू करना
rsMatrixSet एक एलिमेंट सेट करना
rsMatrixTranslate ट्रांसफ़ॉर्मेशन मैट्रिक्स पर ट्रांसलेशन लागू करना
rsMatrixTranspose मैट्रिक्स की जगह को ट्रांसपोज़ करना

फ़ंक्शन

rsExtractFrustumPlanes : फ़्रस्टम प्लेन कैलकुलेट करें

void rsExtractFrustumPlanes(const rs_matrix4x4* viewProj, float4* left, float4* righ, float4* top, float4* bottom, float4* near, float4* far); एपीआई लेवल 24 में जोड़ा गया
void rsExtractFrustumPlanes(const rs_matrix4x4* viewProj, float4* left, float4* right, float4* top, float4* bottom, float4* near, float4* far); एपीआई लेवल 24 और उसके बाद के वर्शन से हटाया गया
पैरामीटर
viewProjमैट्रिक, जिसमें से प्लेन निकालने हैं.
बाएंबाईं ओर मौजूद प्लेन.
दाएंसही विमान.
ऊपरसबसे अच्छा विमान.
सबसे नीचेसबसे नीचे मौजूद प्लेन.
आस-पासहवाई जहाज़ के पास.
दूरदूर का विमान.
righ

व्यू प्रोजेक्शन मैट्रिक्स से छह फ़्रस्टम प्लेन का हिसाब लगाता है

rsIsSphereInFrustum : यह जांचता है कि कोई गोला, फ़्रस्टम प्लेन में है या नहीं

bool rsIsSphereInFrustum(float4* sphere, float4* left, float4* right, float4* top, float4* bottom, float4* near, float4* far);
पैरामीटर
गोलास्फ़ीर को दिखाने वाला float4.
बाएंबाईं ओर मौजूद प्लेन.
दाएंसही विमान.
ऊपरसबसे अच्छा विमान.
सबसे नीचेसबसे नीचे मौजूद प्लेन.
आस-पासहवाई जहाज़ के पास.
दूरदूर का विमान.

अगर गोला, छह फ़्रस्टम प्लेन के अंदर है, तो यह फ़ंक्शन 'सही' दिखाता है.

rsMatrixGet : एक एलिमेंट पाएं

float rsMatrixGet(const rs_matrix2x2* m, uint32_t col, uint32_t row);
float rsMatrixGet(const rs_matrix3x3* m, uint32_t col, uint32_t row);
float rsMatrixGet(const rs_matrix4x4* m, uint32_t col, uint32_t row);
पैरामीटर
mवह मैट्रिक जिससे एलिमेंट निकालना है.
स्‍तंभनिकाले जाने वाले एलिमेंट का शून्य पर आधारित कॉलम.
रोनिकाले जाने वाले एलिमेंट की शून्य पर आधारित लाइन.

मैट्रिक्स का एक एलिमेंट दिखाता है.

चेतावनी: कॉलम और लाइन पैरामीटर का क्रम अनचाहा हो सकता है.

rsMatrixInverse : किसी मैट्रिक्स को बदले बिना उसका इनवर्स बनाता है

bool rsMatrixInverse(rs_matrix4x4* m);
पैरामीटर
mजिस मैट्रिक्स को उलटा करना है.

अगर मैट्रिक को सही तरीके से इनवर्ट किया गया है, तो यह फ़ंक्शन True दिखाता है.

rsMatrixInverseTranspose : किसी मैट्रिक्स को इनवर्ट और ट्रांसपोज़ करता है

bool rsMatrixInverseTranspose(rs_matrix4x4* m);
पैरामीटर
mजिस मैट्रिक में बदलाव करना है.

मैट्रिक को पहले इनवर्ट किया जाता है और फिर ट्रांसपोज़ किया जाता है. अगर मैट्रिक का इनवर्स पाया गया, तो True दिखाता है.

rsMatrixLoad : कोई मैट्रिक लोड या कॉपी करना

void rsMatrixLoad(rs_matrix2x2* destination, const float* array);
void rsMatrixLoad(rs_matrix2x2* destination, const rs_matrix2x2* source);
void rsMatrixLoad(rs_matrix3x3* destination, const float* array);
void rsMatrixLoad(rs_matrix3x3* destination, const rs_matrix3x3* source);
void rsMatrixLoad(rs_matrix4x4* destination, const float* array);
void rsMatrixLoad(rs_matrix4x4* destination, const rs_matrix2x2* source);
void rsMatrixLoad(rs_matrix4x4* destination, const rs_matrix3x3* source);
void rsMatrixLoad(rs_matrix4x4* destination, const rs_matrix4x4* source);
पैरामीटर
गंतव्यसेट की जाने वाली मैट्रिक्स.
ऐरेमैट्रिक को सेट करने के लिए वैल्यू का कलेक्शन. ये ऐरे, मैट्रिक्स के साइज़ के हिसाब से 4, 9 या 16 फ़्लोट लंबे होने चाहिए.
स्रोतसोर्स मैट्रिक्स.

फ़्लोट के ऐरे या किसी अन्य मैट्रिक्स से, मैट्रिक्स के एलिमेंट सेट करें.

अगर किसी कलेक्शन से लोड किया जा रहा है, तो फ़्लोट, पंक्ति के हिसाब से क्रम में होने चाहिए. इसका मतलब है कि एलिमेंट a row 0, column 0 पहले होना चाहिए, उसके बाद एलिमेंट at row 0, column 1 वगैरह.

अगर किसी मैट्रिक से लोड किया जा रहा है और सोर्स, डेस्टिनेशन से छोटा है, तो डेस्टिनेशन के बाकी हिस्से को आइडेंटिटी मैट्रिक के एलिमेंट से भरा जाता है. उदाहरण के लिए, rs_matrix2x2 को rs_matrix4x4 में लोड करने पर, आपको यह दिखेगा:

m00 m01 0.0 0.0
m10 m11 0.0 0.0
0.0 0.0 1.0 0.0
0.0 0.0 0.0 1.0

rsMatrixLoadFrustum : फ़्रस्टम प्रोजेक्शन मैट्रिक्स लोड करना

void rsMatrixLoadFrustum(rs_matrix4x4* m, float left, float right, float bottom, float top, float near, float far);
पैरामीटर
mसेट की जाने वाली मैट्रिक्स.
बाएं
दाएं
सबसे नीचे
ऊपर
आस-पास
दूर

छह क्लिपिंग प्लेन left, right, bottom, top, near, far से पहचाने गए बॉक्स को बदलकर, फ़्रस्टम प्रोजेक्शन मैट्रिक्स बनाता है.

इस प्रोजेक्शन को किसी वेक्टर पर लागू करने के लिए, rsMatrixMultiply() का इस्तेमाल करके, वेक्टर को बनाई गई मैट्रिक्स से गुणा करें.

rsMatrixLoadIdentity : आइडेंटिटी मैट्रिक लोड करें

void rsMatrixLoadIdentity(rs_matrix2x2* m);
void rsMatrixLoadIdentity(rs_matrix3x3* m);
void rsMatrixLoadIdentity(rs_matrix4x4* m);
पैरामीटर
mसेट की जाने वाली मैट्रिक्स.

किसी मैट्रिक्स के एलिमेंट को आइडेंटिटी मैट्रिक्स पर सेट करें.

rsMatrixLoadMultiply : दो मैट्रिक को गुणा करना

void rsMatrixLoadMultiply(rs_matrix2x2* m, const rs_matrix2x2* lhs, const rs_matrix2x2* rhs);
void rsMatrixLoadMultiply(rs_matrix3x3* m, const rs_matrix3x3* lhs, const rs_matrix3x3* rhs);
void rsMatrixLoadMultiply(rs_matrix4x4* m, const rs_matrix4x4* lhs, const rs_matrix4x4* rhs);
पैरामीटर
mसेट की जाने वाली मैट्रिक्स.
lhsप्रॉडक्ट का बायां मैट्रिक्स.
rhsप्रॉडक्ट का सही मैट्रिक.

m को lhs * rhs के मैट्रिक्स प्रॉडक्ट पर सेट करता है.

दो 4x4 ट्रांसफ़ॉर्मेशन मैट्रिक को जोड़ने के लिए, दूसरी ट्रांसफ़ॉर्मेशन मैट्रिक को पहली ट्रांसफ़ॉर्मेशन मैट्रिक से गुणा करें. उदाहरण के लिए, ट्रांसफ़ॉर्मेशन मैट्रिक बनाने के लिए, rsMatrixLoadMultiply(&combined, &s2, &s1) को कॉल करें. यह मैट्रिक, ट्रांसफ़ॉर्मेशन s1 के बाद s2 को लागू करती है.

चेतावनी: वर्शन 21 से पहले, नतीजे को राइट मैट्रिक्स में वापस सेव नहीं किया जा सकता. ऐसा करने पर, नतीजा अस्पष्ट हो जाएगा. इसके बजाय, rsMatrixMulitply का इस्तेमाल करें. उदाहरण के लिए, rsMatrixLoadMultiply (&m2r, &m2r, &m2l) के बजाय, rsMatrixMultiply (&m2r, &m2l) का इस्तेमाल करें. rsMatrixLoadMultiply (&m2l, &m2r, &m2l) उम्मीद के मुताबिक काम करता है.

rsMatrixLoadOrtho : ऑर्थोग्राफ़िक प्रोजेक्शन मैट्रिक लोड करें

void rsMatrixLoadOrtho(rs_matrix4x4* m, float left, float right, float bottom, float top, float near, float far);
पैरामीटर
mसेट की जाने वाली मैट्रिक्स.
बाएं
दाएं
सबसे नीचे
ऊपर
आस-पास
दूर

ऑर्थोग्राफ़िक प्रोजेक्शन मैट्रिक्स बनाता है. यह छह क्लिपिंग प्लेन left, right, bottom, top, near, far से पहचाने गए बॉक्स को यूनिट क्यूब में बदल देता है. इस क्यूब का एक कोना (-1, -1, -1) पर और दूसरा कोना (1, 1, 1) पर होता है.

इस प्रोजेक्शन को किसी वेक्टर पर लागू करने के लिए, rsMatrixMultiply() का इस्तेमाल करके, वेक्टर को बनाई गई मैट्रिक से गुणा करें.

https://en.wikipedia.org/wiki/Orthographic_projection पर जाएं .

rsMatrixLoadPerspective : पर्सपेक्टिव प्रोजेक्शन मैट्रिक लोड करना

void rsMatrixLoadPerspective(rs_matrix4x4* m, float fovy, float aspect, float near, float far);
पैरामीटर
mसेट की जाने वाली मैट्रिक्स.
fovyY-ऐक्सिस के साथ डिग्री में फ़ील्ड ऑफ़ व्यू.
आसपेक्टx / y का अनुपात.
आस-पासक्लिपिंग प्लेन के पास.
दूरफ़ार क्लिपिंग प्लेन.

यह सममित फ़ील्ड ऑफ़ व्यू को ध्यान में रखते हुए, पर्सपेक्टिव प्रोजेक्शन मैट्रिक बनाता है.

इस प्रोजेक्शन को किसी वेक्टर पर लागू करने के लिए, rsMatrixMultiply() का इस्तेमाल करके, वेक्टर को बनाई गई मैट्रिक से गुणा करें.

rsMatrixLoadRotate : रोटेशन मैट्रिक लोड करना

void rsMatrixLoadRotate(rs_matrix4x4* m, float rot, float x, float y, float z);
पैरामीटर
mसेट की जाने वाली मैट्रिक्स.
सड़नाडिग्री में, कितना घुमाना है.
xवेक्टर का X कॉम्पोनेंट, जो रोटेशन की ऐक्सिस है.
yवेक्टर का Y कॉम्पोनेंट, जो घुमाव की धुरी है.
zवेक्टर का Z कॉम्पोनेंट, जो रोटेशन की ऐक्सिस है.

यह फ़ंक्शन, रोटेशन मैट्रिक्स बनाता है. रोटेशन का ऐक्सिस, (x, y, z) वेक्टर है.

किसी वेक्टर को घुमाने के लिए, rsMatrixMultiply() का इस्तेमाल करके, वेक्टर को बनाई गई मैट्रिक्स से गुणा करें.

https://en.wikipedia.org/wiki/Rotation_matrix पर जाएं .

rsMatrixLoadScale : स्केलिंग मैट्रिक लोड करें

void rsMatrixLoadScale(rs_matrix4x4* m, float x, float y, float z);
पैरामीटर
mसेट की जाने वाली मैट्रिक्स.
xx कॉम्पोनेंट को स्केल करने के लिए मल्टीपल.
yy कॉम्पोनेंट को स्केल करने के लिए मल्टीपल.
zz कॉम्पोनेंट को स्केल करने के लिए मल्टीपल.

यह फ़ंक्शन स्केलिंग मैट्रिक्स बनाता है. इसमें किसी वेक्टर के हर कॉम्पोनेंट को किसी संख्या से गुणा किया जाता है. यह संख्या ऋणात्मक हो सकती है.

किसी वेक्टर को स्केल करने के लिए, rsMatrixMultiply() का इस्तेमाल करके, वेक्टर को बनाई गई मैट्रिक्स से गुणा करें.

rsMatrixLoadTranslate : ट्रांसलेशन मैट्रिक लोड करना

void rsMatrixLoadTranslate(rs_matrix4x4* m, float x, float y, float z);
पैरामीटर
mसेट की जाने वाली मैट्रिक्स.
xहर x कॉम्पोनेंट में जोड़ने के लिए संख्या.
yहर y कॉम्पोनेंट में जोड़ने के लिए संख्या.
zहर z कॉम्पोनेंट में जोड़ने के लिए संख्या.

यह फ़ंक्शन ट्रांसलेशन मैट्रिक्स बनाता है. इसमें किसी वेक्टर के हर एलिमेंट में एक संख्या जोड़ी जाती है.

किसी वेक्टर का ट्रांसलेशन करने के लिए, rsMatrixMultiply() का इस्तेमाल करके, वेक्टर को बनाई गई मैट्रिक्स से गुणा करें.

rsMatrixMultiply : किसी मैट्रिक्स को वेक्टर या किसी दूसरी मैट्रिक्स से गुणा करना

float2 rsMatrixMultiply(const rs_matrix2x2* m, float2 in); एपीआई लेवल 14 में जोड़ा गया
float2 rsMatrixMultiply(rs_matrix2x2* m, float2 in); एपीआई लेवल 14 और उसके बाद के वर्शन से हटाया गया
float3 rsMatrixMultiply(const rs_matrix3x3* m, float2 in); एपीआई लेवल 14 में जोड़ा गया
float3 rsMatrixMultiply(const rs_matrix3x3* m, float3 in); एपीआई लेवल 14 में जोड़ा गया
float3 rsMatrixMultiply(rs_matrix3x3* m, float2 in); एपीआई लेवल 14 और उसके बाद के वर्शन से हटाया गया
float3 rsMatrixMultiply(rs_matrix3x3* m, float3 in); एपीआई लेवल 14 और उसके बाद के वर्शन से हटाया गया
float4 rsMatrixMultiply(const rs_matrix4x4* m, float2 in); एपीआई लेवल 14 में जोड़ा गया
float4 rsMatrixMultiply(const rs_matrix4x4* m, float3 in); एपीआई लेवल 14 में जोड़ा गया
float4 rsMatrixMultiply(const rs_matrix4x4* m, float4 in); एपीआई लेवल 14 में जोड़ा गया
float4 rsMatrixMultiply(rs_matrix4x4* m, float2 in); एपीआई लेवल 14 और उसके बाद के वर्शन से हटाया गया
float4 rsMatrixMultiply(rs_matrix4x4* m, float3 in); एपीआई लेवल 14 और उसके बाद के वर्शन से हटाया गया
float4 rsMatrixMultiply(rs_matrix4x4* m, float4 in); एपीआई लेवल 14 और उसके बाद के वर्शन से हटाया गया
void rsMatrixMultiply(rs_matrix2x2* m, const rs_matrix2x2* rhs);
void rsMatrixMultiply(rs_matrix3x3* m, const rs_matrix3x3* rhs);
void rsMatrixMultiply(rs_matrix4x4* m, const rs_matrix4x4* rhs);
पैरामीटर
mप्रॉडक्ट का बायां मैट्रिक्स और सेट किया जाने वाला मैट्रिक्स.
rhsप्रॉडक्ट का सही मैट्रिक.
in

मैट्रिक्स के हिसाब से मैट्रिक्स वैरिएंट के लिए, m को मैट्रिक्स प्रॉडक्ट m * rhs पर सेट करता है.

इस फ़ंक्शन का इस्तेमाल करके, दो 4x4 ट्रांसफ़ॉर्मेशन मैट्रिक को जोड़ने पर, नतीजा देने वाली मैट्रिक में पहले rhs ट्रांसफ़ॉर्मेशन और फिर ओरिजनल m ट्रांसफ़ॉर्मेशन होगा.

मैट्रिक्स और वेक्टर वैरिएंट के लिए, मैट्रिक्स से वेक्टर के बाद के गुणन को दिखाता है, जैसे कि. m * in.

float3 को rs_matrix4x4 से गुणा करने पर, वेक्टर को (1) से बड़ा किया जाता है.

किसी फ़्लोट2 को rs_matrix4x4 से गुणा करने पर, वेक्टर को (0, 1) से बड़ा किया जाता है.

किसी float2 को rs_matrix3x3 से गुणा करने पर, वेक्टर को (0) से बड़ा किया जाता है.

API 14 से, यह फ़ंक्शन पहले आर्ग्युमेंट के तौर पर const मैट्रिक्स लेता है.

rsMatrixRotate : ट्रांसफ़ॉर्मेशन मैट्रिक पर रोटेशन लागू करें

void rsMatrixRotate(rs_matrix4x4* m, float rot, float x, float y, float z);
पैरामीटर
mजिस मैट्रिक में बदलाव करना है.
सड़नाडिग्री में, कितना घुमाना है.
xवेक्टर का X कॉम्पोनेंट, जो रोटेशन की ऐक्सिस है.
yवेक्टर का Y कॉम्पोनेंट, जो घुमाव की धुरी है.
zवेक्टर का Z कॉम्पोनेंट, जो रोटेशन की ऐक्सिस है.

मैट्रिक्स m को रोटेशन मैट्रिक्स से गुणा करें.

यह फ़ंक्शन, पहले रोटेशन करने के लिए ट्रांसफ़ॉर्मेशन मैट्रिक में बदलाव करता है. घुमाव का अक्ष, (x, y, z) वेक्टर है.

किसी वेक्टर पर इस ट्रांसफ़ॉर्मेशन को लागू करने के लिए, rsMatrixMultiply() का इस्तेमाल करके, वेक्टर को बनाई गई मैट्रिक्स से गुणा करें.

rsMatrixScale : ट्रांसफ़ॉर्मेशन मैट्रिक पर स्केलिंग लागू करना

void rsMatrixScale(rs_matrix4x4* m, float x, float y, float z);
पैरामीटर
mजिस मैट्रिक में बदलाव करना है.
xx कॉम्पोनेंट को स्केल करने के लिए मल्टीपल.
yy कॉम्पोनेंट को स्केल करने के लिए मल्टीपल.
zz कॉम्पोनेंट को स्केल करने के लिए मल्टीपल.

मैट्रिक्स m को स्केलिंग मैट्रिक्स से गुणा करें.

यह फ़ंक्शन, स्केलिंग करने के लिए ट्रांसफ़ॉर्मेशन मैट्रिक में बदलाव करता है. स्केलिंग करते समय, किसी वेक्टर के हर कॉम्पोनेंट को किसी संख्या से गुणा किया जाता है. यह संख्या ऋणात्मक हो सकती है.

किसी वेक्टर पर इस ट्रांसफ़ॉर्मेशन को लागू करने के लिए, rsMatrixMultiply() का इस्तेमाल करके, वेक्टर को बनाई गई मैट्रिक्स से गुणा करें.

rsMatrixSet : एक एलिमेंट सेट करें

void rsMatrixSet(rs_matrix2x2* m, uint32_t col, uint32_t row, float v);
void rsMatrixSet(rs_matrix3x3* m, uint32_t col, uint32_t row, float v);
void rsMatrixSet(rs_matrix4x4* m, uint32_t col, uint32_t row, float v);
पैरामीटर
mवह मैट्रिक जिसमें बदलाव किया जाएगा.
स्‍तंभसेट किए जाने वाले एलिमेंट का शून्य पर आधारित कॉलम.
रोसेट किए जाने वाले एलिमेंट की शून्य पर आधारित लाइन.
vसेट की जाने वाली वैल्यू.

मैट्रिक्स का कोई एलिमेंट सेट करना.

चेतावनी: कॉलम और लाइन पैरामीटर का क्रम अनचाहा हो सकता है.

rsMatrixTranslate : ट्रांसफ़ॉर्मेशन मैट्रिक्स पर ट्रांसलेशन लागू करें

void rsMatrixTranslate(rs_matrix4x4* m, float x, float y, float z);
पैरामीटर
mजिस मैट्रिक में बदलाव करना है.
xहर x कॉम्पोनेंट में जोड़ने के लिए संख्या.
yहर y कॉम्पोनेंट में जोड़ने के लिए संख्या.
zहर z कॉम्पोनेंट में जोड़ने के लिए संख्या.

मैट्रिक्स m को ट्रांसलेशन मैट्रिक्स से गुणा करें.

यह फ़ंक्शन, ट्रांसफ़ॉर्मेशन मैट्रिक्स में बदलाव करके, पहले ट्रांसलेशन करता है. ट्रांसलेट करते समय, वेक्टर के हर कॉम्पोनेंट में एक संख्या जोड़ी जाती है.

किसी वेक्टर पर इस ट्रांसफ़ॉर्मेशन को लागू करने के लिए, rsMatrixMultiply() का इस्तेमाल करके, वेक्टर को बनाई गई मैट्रिक्स से गुणा करें.

rsMatrixTranspose : मैट्रिक्स की जगह बदलना

void rsMatrixTranspose(rs_matrix2x2* m);
void rsMatrixTranspose(rs_matrix3x3* m);
void rsMatrixTranspose(rs_matrix4x4* m);
पैरामीटर
mट्रांसपोज़ किया जाने वाला मैट्रिक्स.

मैट्रिक्स m को ट्रांसपोज़ करें.