The object is sitting horizontally in max, now the exported object is standing upright in dx9
I believe the y-z axis is wrong. How do I flip it around? I mean what matrix can I multiply with this wrong matrix?
///
float mat[4][4];
Matrix3 invTM;
int persp;
float hither;
float yon;
D3DXMATRIX m_d3dWorldXform; // your app world transform matrix
D3DXMATRIX m_d3dViewXform; // your app view transform matrix
D3DXMATRIX m_d3dProjXform; // your app projection transform matrix
Interface *ip2 = GetCOREInterface();
ViewExp * pView = ip2->GetActiveViewport(); // Get the viewport in question
GraphicsWindow *gw = pView->getGW(); // Get the GraphicsWindow context
gw->getCameraMatrix( mat, &invTM, &persp, &hither, &yon); // getting these values to work with ... see above for their types
float oneOverDepth = 1.0f / (yon - hither);
// Set the Direct3D Camera View Position and Camera Projection Transforms.
//
// The first matrix is the full projection transformation matrix that
// converts World Coordinates into NPC. This means that the matrix is the
// product of the Camera View Position transformation matrix and the Camera
// Projection matrix. The second matrix is the inverse of the Camera View
// Position transformation matrix so if we multiply this second matrix by
// the first, we get the Camera Projection matrix. If we take the inverse
// of the second matrix, we get the Camera View Position matrix.
//
// The Camera View Position transformation converts World coordinates into
// Camera View Position coordinates where the camera is located at the
// origin. We have been given the inverse of the Camera View Position
// matrix so the first step is to take the inverse of this transform to
// obtain the Camera View Position matrix.
// General conversion from 3ds max coords to Direct3D coords:
//
// 3ds max: (Up, Front, Right) == (+Z, +Y, +X)
//
// Direct3D: (Up, Front, Right) == (+Y, +Z, +X)
//
// Conversion from 3ds max to Direct3D coords:
//
// 3ds max * conversion matrix = Direct3D
//
// [ x y z w ] * | +1 0 0 0 | = [ X Y Z W ]
// | 0 0 +1 0 |
// | 0 +1 0 0 |
// | 0 0 0 +1 |
//
// The View transform below accomplishes this. The standard View transform
// received makes the rotation about the X axis because the assumption was
// to transform to RH coords with the XY plane being the vertical plane
// instead of the XZ plane. The negation of the the Z column does the RH
// to LH flip. Thus, the View transform makes the transition from RH 3ds
// max coords to LH Direct3D coords.
Matrix3 camTM = Inverse(invTM);
// We now have an affine matrix (4x3) with no perspective column (it is
// understood to be (0, 0, 0, 1)). We add the fourth column and flip the
// Z-axis because Direct3D uses a left-handed coordinate system and MAX
// uses a right-handed coordinate system.
// Copy the affine view matrix data
int ki, kj;
MRow *pcvm = camTM.GetAddr();
for (ki = 0; ki < 4; ki++) {
for (kj = 0; kj < 3; kj++) {
m_d3dViewXform.m[ki][kj] = pcvm[ki][kj];
}
}
// Assign the fourth column (perspective terms)
m_d3dViewXform.m[0][3] = m_d3dViewXform.m[1][3] = m_d3dViewXform.m[2][3] = 0.0f;
m_d3dViewXform.m[3][3] = 1.0f;
// Scale the Z-axis (third column) by -1 to flip to left-handed Direct3D
// coordinate system
for (ki = 0; ki < 4; ki++) {
m_d3dViewXform.m[ki][2] *= -1.0f;
}
// Calculate the Direct3D Camera Projection transformation matrix.
//
// First, multiply the MAX full projection matrix by the inverse of the MAX
// Camera View Position matrix to obtain the MAX Camera Projection matrix.
//
// This gives us a correct Direct3D Camera Projection matrix except for the
// lower right quadrant.
//
MRow *pa = invTM.GetAddr();
for (ki = 0; ki < 4; ki++) {
float val = (float)(ki==3);
for (kj = 0; kj < 4; kj++) {
m_d3dProjXform.m[ki][kj] = pa[ki][0] * mat[0][kj] +
pa[ki][1] * mat[1][kj] +
pa[ki][2] * mat[2][kj] +
val * mat[3][kj];
}
}
// Now calculate the lower right quadrant of the Camera Projection matrix
// using the facts that MAX uses an NPC Z-axis range of +1 to -1 whereas
// Direct3D uses an NPC Z-axis range of zero to +1.
//
// For ease of reference, the general forms of the Direct3D Projection
// matrix for perspective and orthographic projections are given below.
//
// Please note that the matrices are specified in row-major order. This
// means that the translate terms are located in the fourth row and the
// projection terms in the fourth column. This is consistent with the way
// MAX, Direct3D, and OpenGL all handle matrices. Even though the OpenGL
// documentation is in column-major form, the OpenGL code is designed to
// handle matrix operations in row-major form.
if (persp) {
// Perspective projection. The general form of the Direct3D Camera
// Projection matrix is:
//
// | 2n/(r-l) 0 0 0 |
// | 0 2n/(t-b) 0 0 |
// | (r+l)/(r-l) (t+b)/(t-b) f/(f-n) 1 |
// | 0 0 -fn/(f-n) 0 |
//
// Construct the lower right four terms correctly for Direct3D.
//
m_d3dProjXform.m[2][2] = yon*oneOverDepth;
m_d3dProjXform.m[2][3] = 1.0f;
m_d3dProjXform.m[3][2] = -(yon*hither*oneOverDepth);
m_d3dProjXform.m[3][3] = 0.0f;
} else {
// Orthographic projection. The general form of the Direct3D Camera
// Projection matrix is:
//
// | 2/(r-l) 0 0 0 |
// | 0 2/(t-b) 0 0 |
// | 0 0 1/(f-n) 0 |
// | (r+l)/(r-l) (t+b)/(t-b) -n/(f-n) 1 |
//
// Construct the lower right four terms correctly for Direct3D.
//
m_d3dProjXform.m[2][2] = oneOverDepth;
m_d3dProjXform.m[2][3] = 0.0f;
m_d3dProjXform.m[3][2] = -(hither*oneOverDepth);
m_d3dProjXform.m[3][3] = 1.0f;
}
Thanks
Jack
