I'm creating a DirectX renderer for a project I previously made in OpenGL, reusing the glm library would be really useful.

Is it possible to convert the glm::lookAt matrix to work with DirectX, I have tried the following but the matrix created by DirectX Math Library is different

	D3DXMatrixLookAtLH( &matView,
		&D3DXVECTOR3( 0.0f, 3.0f, 5.0f ),
		&D3DXVECTOR3( 0.0f, 0.0f, 0.0f ),
		&D3DXVECTOR3( 0.0f, 1.0f, 0.0f ) ); 
	
	glm::mat4 gmatView = glm::lookAt( glm::vec3( 0.0f, 3.0f, 5.0f ),
									glm::vec3( 0.0f, 0.0f, 0.0f ),
									glm::vec3( 0.0f, 1.0f, 0.0f ) );

	float* pt = glm::value_ptr( gmatView );
	D3DXMATRIX matGLConvertView = D3DXMATRIX( pt );

Thanks

Buckeye, you utter legend. After you said that I looked into glm its default is a RightHand projection and look at matrix. Once I use D3DXMatrixPerspectiveFovRH instead of D3DXMatrixLookAtLH it sprung to life :D.

I suggest you to write your own versions of lookAt perspective ortho ect. matrices, and then send them to the GLM guy. You can find the layout of those matrices on msdn or in DirectXMatrix header/inl files.

The code that I "stole". SELF_TYPE is the matrix type.

		SELF_TYPE result;

		vec3<DATA_TYPE> R2 = normalized(eye - at);

		vec3<DATA_TYPE> R0 = cross(up, R2);
		R0 = normalized(R0);

		vec3<DATA_TYPE> R1 = cross(R2, R0);

		vec3<DATA_TYPE> NegEyePosition = -eye;

		DATA_TYPE D0 = dot(R0, NegEyePosition);
		DATA_TYPE D1 = dot(R1, NegEyePosition);
		DATA_TYPE D2 = dot(R2, NegEyePosition);

		result.data[0] = vec4<DATA_TYPE>(R0, D0);
		result.data[1] = vec4<DATA_TYPE>(R1, D1);
		result.data[2] = vec4<DATA_TYPE>(R2, D2);
		result.data[3] = vec4<DATA_TYPE>::GetAxis(3);

		result = transposed(result); // For lazy ppl.

		return result;

The only annoying difference between GL and D3D is that a GL projection matrix (stupidly) needs to scale Z values into a -1 to 1 range, while a D3D projection matrix needs to scale Z values into a 0 to 1 range.

You can 'fix' a GL style projection matrix for use in D3D by concatenating it with a "scale z by 0.5" matrix and a "translate z by 0.5" matrix (or vice versa by concatenating with a "scale z by 2" matrix and a "translate z by -1" matrix).

Or you can glClipControl(GL_UPPER_LEFT, GL_ZERO_TO_ONE) and pray that your players know how to update drivers.

Thanks for the answers guys, my final solution was to use the glm RH ViewMatrix, then implement a projection matrix myself which serves up different z ranges based on a flag of OpenGL or DirectX.

Hodgman, I will give your scale and translate a go, seems like a better solution than making two different matrix's :)