Hi,

I've been brushing up my matrix math because I ran into some issues. To be sure I get it right, I'd like to know if the following is correct:

- I create a World matrix for an object, by multiplying Scale, Rotation and Translation matrices

- this gives we for example:

[ 0.5 0.0 0.2 0.0 ]

[ 0.0 0.4 0.3 0.0 ]

[ 0.0 0.1 0.2 0.0 ]

[ 3.0 2.0 1.0 1.0 ]

When I try to 'read' this matrix I conclude:

- row 1/ 2 / 3 = X / Y / Z axis orientation = scaling + rotation combined (scaling first)

- row 4 = X/Y/Z/W translation

- if I want to extract a vector from the matrix, that gives my either X, Y or Z orientation (without translation), I could use the 1st three components of row 1, 2 or 3

- when I multiply a vector (position/point) with this matrix, for example:

[ 1.0 ]

[ 2.0 ]

[ 0.0 ]

[ 1.0 ]

=> the X component of the vector is only affected by the 1st row of the matrix

=> the Y component of the vector is only affected by the 2nd row of the matrix

=> the Z component of the vector is only affected by the 3rd row of the matrix

Are my assumptions correct or am I overseeing something?

Thanks. Here's an example/ one of my practice cases:

I multiply the X, Y, Z and W component with the first colum of the 4x4 matrix.

For Y I multiply the XYZW components with the 2nd colum of the matrix, etc.

So the resulting new X component, is determined by a multiplicaton of all 'original' vector components with the 1st column of the matrix.

I'm not 100% sure, but I believe directx/3d uses/ expects 'row major' matrices.

And to get for example the seperate axis's, I take the 1st three values of the 1st row for X, 2nd row for Y, 3rd row for Z (containing the rotations/scaling).

This example is a rotation matrix with X rotation is 90%:

Where I believe the 1st 3 values of the 1st row, define a vector which I use as 'X axis' (my explanation in dummy: X and Z influence the result, because there's rotation around Y).

    /** Creates a matrix from our data. */
    void COrientation::CreateMatrix( CMatrix4x4 &_mRet ) const {
        _mRet._11 = m_vRight.x * m_vScale.x;
        _mRet._12 = m_vRight.y * m_vScale.x;
        _mRet._13 = m_vRight.z * m_vScale.x;
        _mRet._14 = 0.0f;

        _mRet._21 = m_vUp.x * m_vScale.y;
        _mRet._22 = m_vUp.y * m_vScale.y;
        _mRet._23 = m_vUp.z * m_vScale.y;
        _mRet._24 = 0.0f;

        _mRet._31 = m_vForward.x * m_vScale.z;
        _mRet._32 = m_vForward.y * m_vScale.z;
        _mRet._33 = m_vForward.z * m_vScale.z;
        _mRet._34 = 0.0f;

        _mRet._41 = m_vPos.x;
        _mRet._42 = m_vPos.y;
        _mRet._43 = m_vPos.z;
        _mRet._44 = 1.0f;
    }

Thanks, in my case it's a left handed system.

Here's my code of composing a model matrix:

D3DXMATRIX* ComposeD3DXWorldMatrix(D3DXMATRIX *pOut, const D3DXVECTOR3 &pScale, const float pXrot, const float pYrot, const float pZrot, const D3DXVECTOR3 pTranslation)
{
    pOut->m[0][0] = std::cos(pYrot) * std::cos(pZrot) * pScale.x;
    pOut->m[0][1] = std::cos(pYrot) * std::sin(pZrot) * pScale.x;
    pOut->m[0][2] = -std::sin(pYrot) * pScale.x;
    pOut->m[0][3] = 0.0f;

    pOut->m[1][0] = (((std::sin(pXrot) * std::sin(pYrot)) * std::cos(pZrot)) + (std::cos(pXrot) * -std::sin(pZrot))) * pScale.y;
    pOut->m[1][1] = (((std::sin(pXrot) * std::sin(pYrot)) * std::sin(pZrot)) + (std::cos(pXrot) * std::cos(pZrot))) * pScale.y;
    pOut->m[1][2] = std::sin(pXrot) * std::cos(pYrot) * pScale.y;
    pOut->m[1][3] = 0.0f;

    pOut->m[2][0] = (((std::cos(pXrot) * std::sin(pYrot)) * std::cos(pZrot)) + (-std::sin(pXrot) * -std::sin(pZrot))) * pScale.z;
    pOut->m[2][1] = (((std::cos(pXrot) * std::sin(pYrot)) * std::sin(pZrot)) + (-std::sin(pXrot) * std::cos(pZrot))) * pScale.z;
    pOut->m[2][2] = std::cos(pXrot) * std::cos(pYrot) * pScale.z;
    pOut->m[2][3] = 0.0f;

    pOut->m[3][0] = pTranslation.x;
    pOut->m[3][1] = pTranslation.y;
    pOut->m[3][2] = pTranslation.z;
    pOut->m[3][3] = 1.0f;

    return pOut;
}

I also draw it out for understanding:

Math is slightly growing on me, luckily

For better clarity I could have named 'XYZW'/ XYZW, columns/ row 0 to 3.

I also found out that I can user either the 2 dimensional array for the d3dxmatrix data [ ][ ] or the '_11, _12 etc.' members (_12 would be 1st row, 2nd col).

In a left handed system

Here's my code of composing a model matrix: