דף זה תורגם על ידי Cloud Translation API.

פונקציות מטריצות של 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.

יש לנו שני סגנונות של פונקציות ליצירת מטריצות טרנספורמציה: Transformation של rsMatrixLoad ו-Transformation של rsMatrix. בסגנון הקודם, מטריית הטרנספורמציה מאוחסנת בארגומנט הראשון. באפשרות השנייה, מטריצה קיימת של טרנספורמציה משתנה כך שהטרנספורמציה החדשה תתבצע קודם. לדוגמה, אם קוראים ל-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);	נוספה ב-רמת API 24
void rsExtractFrustumPlanes(const rs_matrix4x4* viewProj, float4* left, float4* right, float4* top, float4* bottom, float4* near, float4* far);	הוסרה מ-רמת API 24 ואילך

פרמטרים

viewProj	המטריצה שממנה רוצים לחלץ את המישורים.
נשארו	המטוס השמאלי.
ימני	המטוס הנכון.
עליון	המטוס העליון.
תחתון	המטוס התחתון.
ליד	ליד המטוס.
רחוק	המטוס הרחוק.
righ

חישוב 6 מישורי חתך של חרוט משולש מהמטריצה של הקרנה של התצוגה

rsIsSphereInFrustum : בדיקה אם כדור נמצא בתוך המישורים של חרוט החזה

bool rsIsSphereInFrustum(float4* sphere, float4* left, float4* right, float4* top, float4* bottom, float4* near, float4* far);

פרמטרים

כדור	float4 שמייצג את הכדור.
נשארו	המטוס השמאלי.
ימני	המטוס הנכון.
עליון	המטוס העליון.
תחתון	המטוס התחתון.
ליד	ליד המטוס.
רחוק	המטוס הרחוק.

הפונקציה מחזירה את הערך true אם הכדור נמצא בתוך 6 המישורים של גוף דמוי חרוט.

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 מספרים מסוג float, בהתאם לגודל המטריצה.
מקור	מטריצת המקור.

הגדרת הרכיבים של מטריצה ממערך של מספרים מסוג float או ממטריצה אחרת.

אם אתם מעמיסים ממערך, הערכים של המשתנים מסוג float צריכים להיות בסדר של שורות ראשיות, כלומר, המשתנה arow 0, column 0 צריך להיות הראשון, ואחריו המשתנה atrow 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, מכפילים את מטריצת הטרנספורמציה השנייה במטריצת הטרנספורמציה הראשונה. לדוגמה, כדי ליצור מטריצה של טרנספורמציה שמחילה את הטרנספורמציה s1 ואחריה את הטרנספורמציה s2, צריך לבצע קריאה ל-rsMatrixLoadMultiply(&combined, &s2, &s1).

אזהרה: לפני גרסה 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	המטריצה להגדרה.
fovy	שדה הראייה, במעלות לאורך ציר Y.
אספקט	היחס 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	המטריצה להגדרה.
x	מכפיל להגדלת הרכיבים של x.
y	מכפיל להגדלת הרכיבים של ציר y.
z	מכפיל להגדלת הרכיבים של z.

הפונקציה הזו יוצרת מטריצה של שינוי קנה מידה, שבה כל רכיב של וקטור מוכפל במספר. המספר הזה יכול להיות שלילי.

כדי לשנות את קנה המידה של וקטור, מכפילים את הווקטור במטריצה שנוצרה באמצעות 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);	נוספה ב-רמת API 14
float2 rsMatrixMultiply(rs_matrix2x2* m, float2 in);	הוסרו מ-רמת API 14 ואילך
float3 rsMatrixMultiply(const rs_matrix3x3* m, float2 in);	נוספה ב-רמת API 14
float3 rsMatrixMultiply(const rs_matrix3x3* m, float3 in);	נוספה ב-רמת API 14
float3 rsMatrixMultiply(rs_matrix3x3* m, float2 in);	הוסרו מ-רמת API 14 ואילך
float3 rsMatrixMultiply(rs_matrix3x3* m, float3 in);	הוסרו מ-רמת API 14 ואילך
float4 rsMatrixMultiply(const rs_matrix4x4* m, float2 in);	נוספה ב-רמת API 14
float4 rsMatrixMultiply(const rs_matrix4x4* m, float3 in);	נוספה ב-רמת API 14
float4 rsMatrixMultiply(const rs_matrix4x4* m, float4 in);	נוספה ב-רמת API 14
float4 rsMatrixMultiply(rs_matrix4x4* m, float2 in);	הוסרו מ-רמת API 14 ואילך
float4 rsMatrixMultiply(rs_matrix4x4* m, float3 in);	הוסרו מ-רמת API 14 ואילך
float4 rsMatrixMultiply(rs_matrix4x4* m, float4 in);	הוסרו מ-רמת API 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	המטריצה הימנית של המוצר.
בתוך

בגרסת המטריצה על המטריצה, המערכת מגדירה את m כמכפלת המטריצות m * rhs.

כשמשלבים שתי מטריצות טרנספורמציה בגודל 4x4 באמצעות הפונקציה הזו, המטריצה שמתקבלת תואמת לביצוע הטרנספורמציה של ה-rhs ואז הטרנספורמציה המקורית של m.

בגרסת המטריצה על ידי וקטור, הפונקציה מחזירה את המטריצה שמתקבלת לאחר הכפלת הווקטור במטריצה, כלומר m * in.

כשמעכפלים float3 ב-rs_matrix4x4, הוקטור מורחב ב-(1).

כשמעכפלים float2 ב-rs_matrix4x4, הוקטור מתרחב עם (0, 1).

כשמעכפלים float2 ב-rs_matrix3x3, הוקטור מורחב ב-(0).

החל מגרסה 14 של ה-API, הפונקציה הזו מקבלת מטריצה קבועה כארגומנט הראשון.

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	המטריצה שרוצים לשנות.
x	מכפיל להגדלת הרכיבים של x.
y	מכפיל להגדלת הרכיבים של ציר y.
z	מכפיל להגדלת הרכיבים של z.

מכפילים את המטריצה 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 במקום.