Was just curious, does anyone think it's worth using your own matrix math in say a hlsl shader?
I'm assuming:
float3x3 g_mWorld;
float3x3 g_mViewProj;
mul( g_mWorld, g_mViewProj);
Results in:
g_mModel[0][0] * g_mViewProj[0][0] + g_mModel[1][0] * g_mViewProj[0][1] + g_mModel[2][0] * g_mViewProj[0][2]
g_mModel[0][1] * g_mViewProj[0][0] + g_mModel[1][1] * g_mViewProj[0][1] + g_mModel[2][1] * g_mViewProj[0][2]
g_mModel[0][2] * g_mViewProj[0][0] + g_mModel[1][2] * g_mViewProj[0][1] + g_mModel[2][2] * g_mViewProj[0][2]
g_mModel[0][0] * g_mViewProj[1][0] + g_mModel[1][0] * g_mViewProj[1][1] + g_mModel[2][0] * g_mViewProj[1][2]
g_mModel[0][1] * g_mViewProj[1][0] + g_mModel[1][1] * g_mViewProj[1][1] + g_mModel[2][1] * g_mViewProj[1][2]
g_mModel[0][2] * g_mViewProj[1][0] + g_mModel[1][2] * g_mViewProj[1][1] + g_mModel[2][2] * g_mViewProj[1][2]
g_mModel[0][0] * g_mViewProj[2][0] + g_mModel[1][0] * g_mViewProj[2][1] + g_mModel[2][0] * g_mViewProj[2][2]
g_mModel[0][1] * g_mViewProj[2][0] + g_mModel[1][1] * g_mViewProj[2][1] + g_mModel[2][1] * g_mViewProj[2][2]
g_mModel[0][2] * g_mViewProj[2][0] + g_mModel[1][2] * g_mViewProj[2][1] + g_mModel[2][2] * g_mViewProj[2][2]
But couldn't we save time by using our own math?
g_mModel[0][0] * g_mViewProj[0][0] + g_mModel[1][0] * g_mViewProj[0][1]
g_mModel[0][1] * g_mViewProj[0][0] + g_mModel[1][1] * g_mViewProj[0][1]
0.0f
g_mModel[0][0] * g_mViewProj[1][0] + g_mModel[1][0] * g_mViewProj[1][1]
g_mModel[0][1] * g_mViewProj[1][0] + g_mModel[1][1] * g_mViewProj[1][1]
0.0f
g_mModel[0][0] * g_mViewProj[2][0] + g_mModel[1][0] * g_mViewProj[2][1] + g_mModel[2][0]
g_mModel[0][1] * g_mViewProj[2][0] + g_mModel[1][1] * g_mViewProj[2][1] + g_mModel[2][1]
1.0f
That would save 8 addition and 10 multiplications per matrix * matrix operation per object. The same could be done for vertex transforms too. Is it a worthy optimization?