Android NDK开发详解RenderScript之RenderScript 矩阵函数概览

我们为行和列使用从零开始的索引。例如，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* close, float4* fun);	在 API 级别 24 中引入
a	从 API 级别 24 及更高级别中移除
参数
viewProj	用于从中提取平面的矩阵。
左侧	左侧平面。
向右	右侧平面。
上半场	顶平面。
下半场	底部平面。
近	靠近飞机。
远	远平面。
好	
根据视图投影矩阵计算 6 个视锥面

rsIsSphereInFrustum ：检查球体是否位于视锥平面内

bool rsIsSphereInFrustum(float4* sphere, float4* left, float4* right, float4* top, float4* bottom, float4* close, float4* fun);	
参数
球体	代表球面的 float4。
左侧	左侧平面。
向右	右侧平面。
上半场	顶平面。
下半场	底部平面。
近	靠近飞机。
远	远平面。
如果球面位于 6 个视锥平面内，则返回 true。

rsMatrixGet ：获取一个元素

float rsMatrixGet(const rs_matrix2x2* m, uint32_t col, uint32_t 行);	
float rsMatrixGet(const rs_matrix3x3* m, uint32_t col, uint32_t 行);	
float rsMatrixGet(const rs_matrix4x4* m, uint32_t col, uint32_t 行);	
参数
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 个浮点数，具体取决于矩阵大小。
源颜色	源矩阵。
基于浮点数数组或其他矩阵设置矩阵的元素。

如果从数组加载，浮点数应按行主顺序，即应首先列出 row 0, column 0 的元素，其后才是 row 0, column 1 处的元素，依此类推。

如果从矩阵加载且来源小于目的地，则目的地的其余部分会填充身份矩阵的元素。例如，将 rs_matrix2x2 加载到 rs_matrix4x4 中会得到以下结果：

分	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, floatleft, float right, float bottom, float top, float 附近, float fun);	
参数
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	要设置的矩阵。
公关	产品的左矩阵。
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, floatleft, float right, float bottom, float top, float 附近, float fun);	
参数
m	要设置的矩阵。
左侧	
向右	
下半场	
上半场	
近	
远	

构建一个正交投影矩阵，将由六个裁剪面 left, right, bottom, top, near, far 标识的框转换为一个单位立方体，其角为 (-1, -1, -1)，另一角为 (1, 1, 1)。

要将此投影应用到向量，请使用 rsMatrixMultiply() 将向量乘以创建的矩阵。

请参阅 https://zh.wikipedia.org/wiki/Orthographic_projection。

rsMatrixLoadPerspective ：加载透视投影矩阵

void rsMatrixLoadPerspective(rs_matrix4x4* m, float fovy, float pattern, float nearby, float fun);	
参数
m	要设置的矩阵。
浓郁	视野（沿 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)。

从 API 14 开始，此函数将常量矩阵作为第一个参数。

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 转置到位。

本页面上的内容和代码示例受内容许可部分所述许可的限制。Java 和 OpenJDK 是 Oracle 和/或其关联公司的注册商标。

最后更新时间 (UTC)：2023-10-18。