有关dx hlsl shader中矩阵存储方式的一些总结

调用 XMMatrixTranslation(2.0f, 3.0f, 4.0f) 
生成的矩阵为：

1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
2.0, 3.0, 4.0, 1.0,

其在内存中的表示为连续的 16 个元素，记录顺序为行从上到下，行内元素从左到右（ row_major 排列方式 ）。

   

变换向量时，向量左乘该矩阵：

向量的 x 分量，乘上矩阵的第 0 ， 4， 8， 12 个元素，并相加得到新的向量的 x 分量，为： x+2 ； 
向量的 y 分量，乘上矩阵的第 1 ， 5， 9， 13 个元素，并相加得到新的向量的 y 分量，为： y+3 ； 
向量的 z 分量，乘上矩阵的第 2 ， 6， 10， 14 个元素，并相加得到新的向量的 z 分量，为： z+4 。

计算新向量的各个分量时，分别要乘以矩阵中的不连续元素，这样无法充分利用硬件的向量乘法指令。

于是有了 column_major 排列的矩阵（ HLSL 中默认的矩阵排列为 column_major ）。 
矩阵的 16 元素，记录顺序为列从左到右，列内元素从上到下。

这样做向量变换时，向量左乘该矩阵：

向量的 x 分量，乘上矩阵的第 0 ， 1， 2， 3 个元素，并相加得到新的向量的 x 分量，为： x+2 ； 
向量的 y 分量，乘上矩阵的第 4 ， 5， 6， 7 个元素，并相加得到新的向量的 y 分量，为： y+3 ； 
向量的 z 分量，乘上矩阵的第 8 ， 9， 10， 11 个元素，并相加得到新的向量的 z 分量，为： z+4 。

计算新向量的各个分量时，分别乘以矩阵中的连续元素，这样可以充分利用硬件的向量乘法指令，提高效率。

因此，在将矩阵传送到 Shader 中前，先调用 XMMatrixTranspose 将 row_major 排列的矩阵，转换为 column_major 的矩阵。 
这样，与 HLSL 中的矩阵的默认排列方式相同。
 

 

（一）首先，无论dx还是opengl，所表示的矢量和矩阵都是依据线性代数中的标准定义的：
“矩阵A与B的乘积矩阵C的第i行第j列的元素c(ij)等于A的第i行于B的第j列的对应元素乘积的和。”（实用数学手册，科学出版社，第二版）
例如c12 = a11*b11+a12*b21+a12*b13...

 

（二）在明确了这一点后，然后我们再看“矩阵的存储方式”，矩阵存储方式有两种，一种是“行主序（row-major order）/行优先”，另一种就是“列主序（column-major order）/列优先”
1）Direct3D 采用行主序存储

“Effect matrix parameters and HLSL matrix variables can define whether the value is a row-major or column-major matrix; however, the DirectX APIs always treat D3DMATRIX and D3DXMATRIX as row-major.”（见d3d9 document/Casting and Conversion 一节）
2）OpenGL 采用列主序存储
“The m parameter points to a 4x4 matrix of single- or double-precision floating-point values stored in column-major order. That is, the matrix is stored as follows”
（见msdn glLoadMatrixf　API说明）

存储顺序说明了线性代数中的矩阵如何在线性的内存数组中存储，d3d 将每一行在数组中按行存储，而opengl将每一列存储到数组的每一行中：
　　　　  线性代数意义的同一个矩阵，在d3d 和　ogl 中却有不同的存储顺序
              线代：a11,a12,a13,a14               d3d :  a11,a12,a13,a14                   gl: a11,a21,a31,a41
                       a21,a22,a23,a24                         a21,a22,a23,a24                       a12,a22,a32,a42
                       a31,a32,a33,a34                         a31,a32,a33,a34                       a13,a23,a33,a43
                       a41,a42,a43,a44                         a41,a42,a43,a44                       a14,a24,a34,a44

（三）矩阵乘法顺序和规则

矩阵乘法在线性代数中的定义是确定的，然而在不同的实现中出现了“左乘”和“右乘”的区别，或者叫做“前乘（pre-multiply），后乘（post-multiply）”
这个规则取决于vector的表示形式，即行向量还是列向量。如果是行向量，其实就是一个行矩阵。那么表示线性代数意义的“行x列”，就是前乘。矩阵乘法也是如此。
如d3d中，
                        

                              

D3D 是行向量，行优先存储，OpenGL是列向量，列优先存储。同一个矩阵用D3D存储还是用opengl存储虽然不同，但是变换的结果却是相同，
因为opengl 变换向量是把向量视作列向量，并同矩阵的每一列相乘，用来实现线性代数中同一个变换。

我们通常很难看到opengl变换坐标的代码，以下代码出自opengl source code，让我们一窥顶点变换的“庐山真面目”

void FASTCALL __glXForm3(__GLcoord *res, const __GLfloat v[3], const __GLmatrix *m)
{
    __GLfloat x = v[0];
    __GLfloat y = v[1];
    __GLfloat z = v[2];

    res->x = x*m->matrix[0][0] + y*m->matrix[1][0] + z*m->matrix[2][0]
 + m->matrix[3][0];
    res->y = x*m->matrix[0][1] + y*m->matrix[1][1] + z*m->matrix[2][1]
 + m->matrix[3][1];
    res->z = x*m->matrix[0][2] + y*m->matrix[1][2] + z*m->matrix[2][2]
 + m->matrix[3][2];
    res->w = x*m->matrix[0][3] + y*m->matrix[1][3] + z*m->matrix[2][3]
 + m->matrix[3][3];
}

可见确实如上所述，“OPENGL列向量和矩阵的每一列相乘，仍然表示线性代数行向量和矩阵的每一行相乘”
再来看一下opengl 矩阵相乘，“用a的每一列去乘b的每一行”。

/*
** Compute r = a * b, where r can equal b.
*/
void FASTCALL __glMultMatrix(__GLmatrix *r, const __GLmatrix *a, const __GLmatrix *b)
{
    __GLfloat b00, b01, b02, b03;
    __GLfloat b10, b11, b12, b13;
    __GLfloat b20, b21, b22, b23;
    __GLfloat b30, b31, b32, b33;
    GLint i;

    b00 = b->matrix[0][0]; b01 = b->matrix[0][1];
        b02 = b->matrix[0][2]; b03 = b->matrix[0][3];
    b10 = b->matrix[1][0]; b11 = b->matrix[1][1];
        b12 = b->matrix[1][2]; b13 = b->matrix[1][3];
    b20 = b->matrix[2][0]; b21 = b->matrix[2][1];
        b22 = b->matrix[2][2]; b23 = b->matrix[2][3];
    b30 = b->matrix[3][0]; b31 = b->matrix[3][1];
        b32 = b->matrix[3][2]; b33 = b->matrix[3][3];

    for (i = 0; i < 4; i++) {
 r->matrix[i][0] = a->matrix[i][0]*b00 + a->matrix[i][1]*b10
     + a->matrix[i][2]*b20 + a->matrix[i][3]*b30;
 r->matrix[i][1] = a->matrix[i][0]*b01 + a->matrix[i][1]*b11
     + a->matrix[i][2]*b21 + a->matrix[i][3]*b31;
 r->matrix[i][2] = a->matrix[i][0]*b02 + a->matrix[i][1]*b12
     + a->matrix[i][2]*b22 + a->matrix[i][3]*b32;
 r->matrix[i][3] = a->matrix[i][0]*b03 + a->matrix[i][1]*b13
     + a->matrix[i][2]*b23 + a->matrix[i][3]*b33;

 

 

文章内容引用自以下链接：

1：https://blog.csdn.net/icbm/article/details/78882415 
2：https://blog.csdn.net/kupepoem/article/details/87858418