Jump to content

  • Log In with Google      Sign In   
  • Create Account


#Actuallucky6969b

Posted 21 December 2012 - 08:45 PM

Comment on this code snippet?
The eye pos is very weird.
Thanks
Jack
	//// 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;
  }
  D3DXVECTOR3 v;
  D3DXQUATERNION q;
  D3DXVECTOR3 s;

  D3DXMatrixDecompose(&s, &q, &v, &d3dViewXform);
  DOMElement *elem1 = doc->createElement(L"Eye-Pos");

#2lucky6969b

Posted 21 December 2012 - 08:36 PM

Comment on this code snippet?
The eye pos is very weird.
Thanks
Jack
	//// 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;
									}

									D3DXVECTOR3 v;
									D3DXQUATERNION q;
									D3DXVECTOR3 s;

									D3DXMatrixDecompose(&s, &q, &v, &d3dViewXform);
	 								DOMElement *elem1 = doc->createElement(L"Eye-Pos");

#1lucky6969b

Posted 21 December 2012 - 08:34 PM

I want to retrieve back the eye position of the camera when a view matrix is given.
How can I achieve that? Any good articles that I can take a look at?
Thanks
Jack

PARTNERS