หน้านี้ได้รับการแปลโดย Cloud Translation API

ฟังก์ชันเมตริกซ์ของ RenderScript

ภาพรวม

ฟังก์ชันเหล่านี้ช่วยให้คุณจัดการกับเมทริกซ์สี่เหลี่ยมจัตุรัสที่มีลําดับชั้น 2x2, 3x3 และ 4x4 ได้ ซึ่งมีประโยชน์อย่างยิ่งสำหรับการเปลี่ยนรูปแบบกราฟิก และเข้ากันได้กับ OpenGL

เราใช้ดัชนีฐาน 0 สำหรับแถวและคอลัมน์ เช่น องค์ประกอบสุดท้ายของ rs_matrix4x4 จะอยู่ที่ (3, 3)

RenderScript ใช้เมทริกซ์แบบคอลัมน์หลักและเวกเตอร์ตามคอลัมน์ การเปลี่ยนรูปแบบเวกเตอร์จะทําโดยการคูณเวกเตอร์ในภายหลัง เช่น (matrix * vector) ตามที่ระบุโดย rsMatrixMultiply()

หากต้องการสร้างเมทริกซ์การเปลี่ยนรูปแบบที่ทำการแปลง 2 ครั้งพร้อมกัน ให้คูณเมทริกซ์ต้นทาง 2 รายการ โดยให้การเปลี่ยนรูปแบบแรกเป็นอาร์กิวเมนต์ด้านขวา เช่น หากต้องการสร้างเมทริกซ์การเปลี่ยนรูปแบบที่ใช้การเปลี่ยนรูปแบบ s1 ตามด้วย s2 ให้เรียกใช้ rsMatrixLoadMultiply(&combined, &s2, &s1) ซึ่งมาจาก s2 * (s1 * v) ซึ่งก็คือ (s2 * s1) * v

เรามีฟังก์ชัน 2 รูปแบบในการสร้างเมทริกซ์การเปลี่ยนรูปแบบ ได้แก่ Transformation ของ rsMatrixLoad และ Transformation ของ rsMatrix รูปแบบแรกจะจัดเก็บเมทริกซ์การเปลี่ยนรูปแบบไว้ในอาร์กิวเมนต์แรก ส่วนหลังจะแก้ไขเมทริกซ์การเปลี่ยนรูปแบบที่มีอยู่เพื่อให้การเปลี่ยนรูปแบบใหม่เกิดขึ้นก่อน เช่น หากคุณเรียกใช้ rsMatrixTranslate() ในเมทริกซ์ที่มีการสเกลแล้ว เมทริกซ์ที่ได้เมื่อนำไปใช้กับเวกเตอร์จะทำการแปลก่อนแล้วจึงทำการสเกล

สรุป

ฟังก์ชัน
rsExtractFrustumPlanes	คำนวณระนาบฟรัสตัม
rsIsSphereInFrustum	ตรวจสอบว่าทรงกลมอยู่ในระนาบทรงกรวยหรือไม่
rsMatrixGet	รับองค์ประกอบ 1 รายการ
rsMatrixInverse	หาอินเวอร์สเมทริกซ์ในตำแหน่ง
rsMatrixInverseTranspose	เปลี่ยนรูปแบบและสลับที่ของเมทริกซ์
rsMatrixLoad	โหลดหรือคัดลอกเมทริกซ์
rsMatrixLoadFrustum	โหลดเมทริกซ์การฉายภาพกรวย
rsMatrixLoadIdentity	โหลดเมทริกซ์ข้อมูลประจำตัว
rsMatrixLoadMultiply	คูณเมทริกซ์ 2 รายการ
rsMatrixLoadOrtho	โหลดเมทริกซ์การฉายภาพออร์โธกราฟิก
rsMatrixLoadPerspective	โหลดเมทริกซ์การฉายภาพด้วยมุมมอง
rsMatrixLoadRotate	โหลดเมทริกซ์การหมุน
rsMatrixLoadScale	โหลดเมทริกซ์การปรับขนาด
rsMatrixLoadTranslate	โหลดเมทริกซ์การแปล
rsMatrixMultiply	คูณเมทริกซ์ด้วยเวกเตอร์หรือเมทริกซ์อื่น
rsMatrixRotate	ใช้การหมุนกับเมทริกซ์การเปลี่ยนรูปแบบ
rsMatrixScale	ใช้การปรับขนาดกับเมทริกซ์การเปลี่ยนรูปแบบ
rsMatrixSet	ตั้งค่าองค์ประกอบ 1 รายการ
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 ที่แสดงทรงกลม
ซ้าย	เครื่องบินด้านซ้าย
ขวา	เครื่องบินที่ถูกต้อง
ด้านบน	เครื่องบินด้านบน
ด้านล่าง	เครื่องบินด้านล่าง
บริเวณใกล้ๆ	ใกล้เครื่องบิน
ไกล	เครื่องบินที่อยู่ไกล

แสดงผลเป็น "จริง" หากทรงกลมอยู่ภายในระนาบทรงกรวย 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	เมทริกซ์ที่จะดึงองค์ประกอบ
คอลัมน์	คอลัมน์แบบนับจาก 0 ขององค์ประกอบที่จะดึงข้อมูล
แถว	แถวขององค์ประกอบที่จะดึงข้อมูลโดยนับจาก 0

แสดงผลองค์ประกอบเดียวของเมทริกซ์

คําเตือน: ลําดับของพารามิเตอร์คอลัมน์และแถวอาจไม่เป็นไปตามที่คาดไว้

rsMatrixInverse : เปลี่ยนเมทริกซ์ให้เป็นรูปแบบย้อนกลับ

bool rsMatrixInverse(rs_matrix4x4* m);

พารามิเตอร์

m	เมทริกซ์ที่จะหาอินเวอร์ส

แสดงค่า "จริง" หากผนวกเมทริกซ์สลับกันได้สําเร็จ

rsMatrixInverseTranspose : เปลี่ยนค่าเมทริกซ์ให้เป็นค่าย้อนกลับและเปลี่ยนค่าเมทริกซ์

bool rsMatrixInverseTranspose(rs_matrix4x4* m);

พารามิเตอร์

m	ตารางเพื่อแก้ไข

ระบบจะเปลี่ยนรูปแบบเมทริกซ์ก่อนแล้วจึงเปลี่ยนรูปแบบกลับ แสดงค่า "จริง" หากหาอินเวอร์สเมทริกซ์ได้สําเร็จ

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	เมทริกซ์ที่จะตั้งค่า
ซ้าย
ขวา
ด้านล่าง
ด้านบน
บริเวณใกล้ๆ
ไกล

สร้างเมทริกซ์การฉายภาพกรวยตัด ซึ่งจะเปลี่ยนรูปกล่องที่ระบุโดยระนาบการตัด 6 ระนาบ 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 : คูณเมทริกซ์ 2 รายการ

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 2 รายการ ให้คูณเมทริกซ์การเปลี่ยนรูปแบบที่ 2 ด้วยเมทริกซ์การเปลี่ยนรูปแบบที่ 1 เช่น หากต้องการสร้างเมทริกซ์การเปลี่ยนรูปแบบที่ใช้การเปลี่ยนรูปแบบ 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	เมทริกซ์ที่จะตั้งค่า
ซ้าย
ขวา
ด้านล่าง
ด้านบน
บริเวณใกล้ๆ
ไกล

สร้างเมทริกซ์การฉายภาพออร์โธกราฟิก ซึ่งเปลี่ยนกล่องที่ระบุโดยระนาบการครอบตัด 6 ระนาบ left, right, bottom, top, near, far ให้เป็นลูกบาศก์หน่วยที่มีมุมที่ (-1, -1, -1) และมุมตรงข้ามที่ (1, 1, 1)

ดูที่ 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 2 รายการโดยใช้ฟังก์ชันนี้ เมทริกซ์ที่ได้จะสอดคล้องกับการเปลี่ยนรูปแบบ rhs ก่อนแล้วตามด้วยการเปลี่ยนรูปแบบ m เดิม

สำหรับเมทริกซ์ตามตัวแปรเวกเตอร์ จะแสดงผลหลังการคูณเวกเตอร์ด้วยเมทริกซ์ นั่นคือ m * in

เมื่อคูณ float3 กับ rs_matrix4x4 ระบบจะขยายเวกเตอร์ด้วย (1)

เมื่อคูณ float2 กับ 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	ตารางที่จะแก้ไข
x	คูณเพื่อปรับขนาดคอมโพเนนต์ x
y	คูณเพื่อปรับขนาดองค์ประกอบ y
z	คูณเพื่อปรับขนาดคอมโพเนนต์ z

คูณเมทริกซ์ m ด้วยเมทริกซ์การปรับขนาด

ฟังก์ชันนี้จะแก้ไขเมทริกซ์การเปลี่ยนรูปแบบเพื่อทำการขยายขนาดก่อน เมื่อปรับขนาด ระบบจะคูณองค์ประกอบแต่ละรายการของเวกเตอร์ด้วยตัวเลข ตัวเลขนี้อาจเป็นค่าลบได้

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	เมทริกซ์ที่จะแก้ไข
คอลัมน์	คอลัมน์แบบนับจากศูนย์ขององค์ประกอบที่จะตั้งค่า
แถว	แถวที่จะเริ่มนับจาก 0 ขององค์ประกอบที่จะตั้งค่า
v	ค่าที่จะตั้ง

ตั้งค่าองค์ประกอบของเมทริกซ์

rsMatrixTranslate : ใช้การเปลี่ยนรูปแบบกับเมทริกซ์การเปลี่ยนรูปแบบ

void rsMatrixTranslate(rs_matrix4x4* m, float x, float y, float z);

พารามิเตอร์

m	ตารางที่จะแก้ไข
x	จํานวนที่จะเพิ่มลงในคอมโพเนนต์ x แต่ละรายการ
y	จํานวนที่จะเพิ่มลงในคอมโพเนนต์ y แต่ละรายการ
z	จํานวนที่จะเพิ่มลงในคอมโพเนนต์ z แต่ละรายการ

คูณเมทริกซ์ m ด้วยเมทริกซ์การแปล

ฟังก์ชันนี้จะแก้ไขเมทริกซ์การเปลี่ยนรูปแบบเพื่อทำการแปลก่อน เมื่อแปล จะมีการเพิ่มตัวเลขลงในองค์ประกอบแต่ละรายการของเวกเตอร์

rsMatrixTranspose : สลับตำแหน่งเมทริกซ์

void rsMatrixTranspose(rs_matrix2x2* m);
void rsMatrixTranspose(rs_matrix3x3* m);
void rsMatrixTranspose(rs_matrix4x4* m);

พารามิเตอร์

m	เมทริกซ์ที่จะสลับ

สลับเมทริกซ์ m เข้าที่