void Render( D3DXMATRIX mView, D3DXMATRIX mProj )
	{
		D3DXMATRIX inv_base_bone, inv_rb_world, rb_world, inv_world, world, rot, pos, inv_pos; // Define Matices.
		vector<D3DXMATRIX> matrices; // Create matrix array.
		matrices.resize(bones.size()); // Resize matrix array to fit all bone actors
		bones[mesh->root_bone]->getGlobalPose().getColumnMajor44( rb_world); // Get root bone matrix.
		D3DXMatrixInverse( &inv_rb_world, NULL, &rb_world); // Inverse root bone matrix.
		D3DXMatrixMultiply( &inv_world, &inv_rb_world, &mesh->bones[mesh->root_bone].matrix  ); // Get inversed world matrix.
		D3DXMatrixInverse( &world, NULL, &inv_world); // Get world matrix
		for(UINT i = 0; i < bones.size(); i++ )
		{
			bones->getGlobalPose().getColumnMajor44( matrices ); // Get world space bone matrix.
			if( mesh->bones.size() > 0) // Check if there are any bones in this mesh, if not then this bone actor was created from the mesh and should be in world space. 
			{
				D3DXMatrixMultiply( &matrices, &matrices, &inv_world ); // Bring the bone in to model space.
				D3DXMatrixInverse( &inv_base_bone, NULL, &mesh->bones.matrix ); // Get the inverse of the bone's model space matrix. 
				D3DXMatrixMultiply( &matrices, &inv_base_bone, &matrices ); // Multiply the matrix by the inverse of the bone's model space matrix so that the bone moves by the difference.

				// I thought the code below would give the matrix the correct center of rotation but it's still at the origin.
				D3DXMatrixTranslation( &pos, mesh->bones.matrix._41, mesh->bones.matrix._42, mesh->bones.matrix._43 ); // Create translation matrix with zero rotation.
				rot = matrices; // Create rotation matrix.
				rot._41 = 0; rot._42 = 0;rot._43 = 0; // Set rotation matrix's translation to [0, 0 ,0]
				D3DXMatrixMultiply( &matrices, &pos, &rot ); // Rotate the matrix with a correct translation.
				D3DXMatrixInverse( &inv_pos, NULL, &pos ); // Get the inverse of the translation matrix. 
				D3DXMatrixMultiply( &matrices, &matrices, &inv_pos ); // Correct the translation back.

				D3DXMatrixMultiply( &matrices, &matrices, &world ); // Put the bone back in to world space.
			}
		}
		mesh->Render( matrices, mView, mProj ); // Send all bone matrices, view matrix and the projection matrix to be rendered.
		matrices.clear(); // Delete the list of matrices.
	}

Texture2D txDiffuse
< 
string UIName = "Base Texture";
>;
SamplerState samLinear
{
    Filter = MIN_MAG_MIP_LINEAR;
    AddressU = Wrap;
    AddressV = Wrap;
};

TextureCube txEnvironment
<
string UIName = "Environment Map";
>;
SamplerState envSampler
{
	Filter = MIN_MAG_MIP_LINEAR;
	AddressU = Clamp;
	AddressV = Clamp;
	AddressW = Clamp;
};

float Environment_map_intensity
<
	string UIName = "Intensity";
	float UIMin = 0.000000;
	float UIMax = 1.000000;
	float UIStep = 0.01;
	string UIWidget = "slider";
> = 1.000000;

float4 Ambient  <
	string UIName = "Ambient";
> = float4( 0.47f, 0.47f, 0.47f, 1.0f );
	
float4 Diffuse  <
	string UIName = "Diffuse";
> = float4( 0.47f, 0.47f, 0.47f, 1.0f );

float4 lightPos : Position <  string UIName = "Light Position"; string Object = "PointLight";> ={0.0f, 0.0f, -10.0f, 0.0f};

float4x4 World				: WORLD;
float4x4 View				: WORLDVIEW;
float4x4 Projection			: PROJECTION;
float4x4 Bones[256]			: WORLDMATRIXARRAY;

struct VS_INPUT
{
	float4 pos			: POSITION;
	float3 norm			: NORMAL;
	float2 tex			: TEXCOORD0;
	float4 bw			: TEXCOORD1;
	float4 bi			: TEXCOORD2;
};

struct PS_INPUT
{
	float4 pos			: SV_POSITION;
	float4 pos2			: POSITION;
	float2 tex			: TEXCOORD0;
	float3 norm			: NORMAL;
};


PS_INPUT VS( VS_INPUT In )
{
	PS_INPUT Out = (PS_INPUT)0;
   	Out.pos = 0;
    	Out.pos += mul(In.pos, Bones[In.bi.x]) * In.bw.x;
    	Out.pos += mul(In.pos, Bones[In.bi.y]) * In.bw.y;
    	Out.pos += mul(In.pos, Bones[In.bi.z]) * In.bw.z;
    	Out.pos += mul(In.pos, Bones[In.bi.w]) * In.bw.w;

	Out.norm = 0;

	Out.norm += mul(In.norm, (float3x3)Bones[In.bi.x]) * In.bw.x;
	Out.norm += mul(In.norm, (float3x3)Bones[In.bi.y]) * In.bw.y;
	Out.norm += mul(In.norm, (float3x3)Bones[In.bi.z]) * In.bw.z;
	Out.norm += mul(In.norm, (float3x3)Bones[In.bi.w]) * In.bw.w;

    	Out.pos = mul(mul(Out.pos, View), Projection);
	Out.tex = In.tex;
	return Out;
}


float4 PS( PS_INPUT input) : SV_Target
{
float4 color = txDiffuse.Sample( samLinear, input.tex );
float a = color.w;
color = (color * (dot(input.norm,normalize(input.pos2-lightPos)))) + ( Environment_map_intensity * txEnvironment.Sample( envSampler, -reflect( normalize( input.pos2 - View[3] ).xyz, input.norm.xyz )));
color.w = a;
return color;
}

technique10 Render
{
	pass P0
	{
		SetVertexShader( CompileShader( vs_4_0, VS() ) );
		SetGeometryShader( NULL );
		SetPixelShader( CompileShader( ps_4_0, PS() ) );
	}
}

   glPushMatrix();   if(!translateTo.atOrigin()){      glTranslated(translateTo.x, translateTo.y, translateTo.z);   }   if(!scaleTo.atOrigin()){      glScaled(scaleTo.x, scaleTo.y, scaleTo.z);   }   if(!rotateTo.atOrigin()){      glTranslated(rotateOrigin.x, rotateOrigin.y, rotateOrigin.z);      glRotated(rotateTo.x, 1.0, 0.0, 0.0);      glRotated(rotateTo.y, 0.0, 1.0, 0.0);      glRotated(rotateTo.z, 0.0, 0.0, 1.0);      glTranslated(-rotateOrigin.x, -rotateOrigin.y, -rotateOrigin.z);   }   drawthebone   glPopMatrix()