Let's summarize what I have done
First, I didn't export the meshes to left-handed system and now I didn't flip the axis
But I converted my Cameras as follows
//// Start exporting View and projection matrices
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.
// View Matrix in 3ds max, inverse's inverse to become original [Jacky Luk]
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++) {
d3dViewXform.m[ki][kj] = pcvm[ki][kj];
}
}
// Assign the fourth column (perspective terms)
d3dViewXform.m[0][3] = d3dViewXform.m[1][3] = d3dViewXform.m[2][3] = 0.0f;
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++) {
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++) {
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.
//
d3dProjXform.m[2][2] = yon*oneOverDepth;
d3dProjXform.m[2][3] = 1.0f;
d3dProjXform.m[3][2] = -(yon*hither*oneOverDepth);
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.
//
d3dProjXform.m[2][2] = oneOverDepth;
d3dProjXform.m[2][3] = 0.0f;
d3dProjXform.m[3][2] = -(hither*oneOverDepth);
d3dProjXform.m[3][3] = 1.0f;
}
D3DXMATRIX invView;
D3DXMatrixInverse(&invView, NULL, &d3dViewXform);
D3DXVECTOR3 v;
D3DXQUATERNION q;
D3DXVECTOR3 s;
D3DXMatrixDecompose(&s, &q, &v, &invView);
//D3DXVECTOR3 v(d3dViewXform.m[3][0], d3dViewXform.m[3][1], d3dViewXform.m[3][2]);
DOMElement *elem1 = doc->createElement(L"Eye-Pos");
this->SetXYZ(e1, elem1, v);
DOMElement *elem2 = doc->createElement(L"ViewTransformation");
this->SetMatrix(e1, elem2, d3dViewXform);
DOMElement *elem3 = doc->createElement(L"ProjectionTransformation");
this->SetMatrix(e1, elem3, d3dProjXform);
Next, I set the Warehouse to 0,0,0 and no rotation at all
and then I set the counter balance to 0,10,0 and no rotation at all, and it sits on the ground level
What steps was I doing wrong so that it made the y and z axis pointing in the wrong directions?
Thanks
Jack
