Hello,

while implementing skinning support to my engine and therefore my mesh file format, I'm down to one problem: The inverse bind pose matrices (at least of my test model) don't match with what would be needed to render it correctly. I've converted the Tiny.x - mesh from the DirectX9-SDK to my own mesh format, and I've verified up until now that all data is 100% matching, minus the bind pose/offset matrix.

I am calculating the matrix by traversing the bone hierachy, and then inversing the absolute transform of each bone:

void MeshSkeleton::ProcessSkeleton(void)
{
	m_vMatrices.clear();
	size_t numBone = 0;

	ProcessBone(m_root, nullptr, numBone);
}

void MeshSkeleton::ProcessBone(Bone& bone, Bone* pParent, size_t& numBone)
{
	if(pParent)
		bone.mAbsolute = bone.mRelative * pParent->mAbsolute;
	else
		bone.mAbsolute = bone.mRelative;
			
	// in case the inverse bind poses have already been calculated, output the final bone matrix
	if(!m_vInvBindPoses.empty())
		m_vMatrices.push_back(m_vInvBindPoses[numBone] * bone.mAbsolute);
	else
		m_vMatrices.push_back(math::MatIdentity());

	numBone++;

	for(auto& child : bone.m_vChildren)
	{
		ProcessBone(child, &bone, numBone);
	}
}

void MeshSkeleton::CalculateBindPoses(void)
{
	m_vInvBindPoses.clear();
	CalculateBindPose(m_root);
}

void MeshSkeleton::CalculateBindPose(Bone& bone)
{
	m_vInvBindPoses.push_back(bone.mAbsolute.inverse());

	for(auto& child : bone.m_vChildren)
	{
		CalculateBindPose(child);
	}
}

First, ProcessSceleton is called, then CalculateBindPoses. The absolute matrices are identically to those of the Tiny.x-mesh when loaded in the sample, so there should be no problem here. However, when I look at the offset matrices from the sample:

    // get each of the bone offset matrices so that we don't need to get them later
        for( iBone = 0; iBone < cBones; iBone++ )
 {
            pMeshContainer->pBoneOffsetMatrices[iBone] = *( pMeshContainer->pSkinInfo->GetBoneOffsetMatrix( iBone ) );
        }

They aren't even similiar to mine in any way shape or form (I checked the correct bones).

Now I can fix this by storing the offset matrix from pSkinInfo in the mesh file and load them with the file (that way the animation works correctly), but I am wondering about the reasoning behind this. Is there some error in my calculations? Or is the offset-matrix calculated differently in the DirectX9-file format?

Need a bit more information. What are the matrices "mRelative" and "mAbsolute?" Are those the bind pose bone matrices "relative-to-parent" and "relative-to-root?" Without being sure, I can't really tell if your code is correct.

I'll try to explain things in more detail. mRelative is the boens local transform, relative to the parent - at least I assume, since I'm multiplying it with the parents global transform (mAbsolute) iteratively. I'm really not that into the terminology, I hope it makes a little more sense that way. If you look at the Tiny.x-file, the "relative" matrices would be those:

Frame Scene_Root {
 

 FrameTransformMatrix {
  1.000000,0.000000,0.000000,0.000000,0.000000,1.000000,0.000000,0.000000,0.000000,0.000000,1.000000,0.000000,0.000000,0.000000,0.000000,1.000000;;
 }

 Frame body {
  

  FrameTransformMatrix {
   1.278853,0.000000,-0.000000,0.000000,0.000000,0.000000,1.123165,0.000000,0.000000,-1.470235,0.000000,0.000000,0.135977,2.027985,133.967667,1.000000;;
  }	

  Frame {
   

   FrameTransformMatrix {
    1.000000,-0.000000,-0.000000,0.000000,-0.000000,1.000000,0.000000,0.000000,-0.000000,0.000000,1.000000,0.000000,-0.142114,0.000023,-49.556850,1.000000;;
   }

equivalent to the frame-transform matrices here, and "absolute" would be calculated by multiplying them up over the hierachy.

It's not clear what you're asking. If you're loading tiny.x anyway, why not use the offsets?

I mentioned (though sparsly) in the beginning that I have a custom mesh file that I use for rendering, I'm only loading Tiny.x in my mesh-converter to port it to my format, mainly since I don't have access to a modelling program at the moment and needed something to test. I can store the offsets in my mesh format, sure, but I'd nevertheless like to know why I can't calculate the correct inverse bind pose myself, and whether this is a fault with my algorithm, or the way x-files are set up (or maybe some issue with the tiny-mesh itself?).

Not sure what you're doing here. You have another routine for doing the calc. EDIT: And if the bindposes have been calculated, why are you multiplying them (again) by the absolute?

I calculate the final matrices that gets sent to the shader for each bone there. This method gets called once in the beginning before the inv-bind poses are calculated, and every time the skeleton is updated, so that the final matrices for the shader are recalculated. This would create all identity matrices without animation, but once I start to apply the animation, I get the matrices that move the vertices. Again, apologies for my inability to use the right terminology, I hope you can still follow me.

[ I wrote an article on animating skinned meshes using matrices, very similar to what you're doing. Unfortunately, it's still in moderator approval. Hopefully it won't be too long before it's available. ]

I'm kind of sad that it wasn't available earlier, could have probably saved me a few hours of lifetime. I'll check it out once it is open anyway!

Be sure to see the edited comments in my last post. The index order of the bone matrices is likely the problem.

Ah, I must have finished my post shortly before your edit ;)

EDIT: The biggest question - are you sure the bone numbers you use (ordered by hierarchy), are in the correct order to match the skininfo numbers? You use only children of frames, so I assume you somewhere resolve sibling frames into another child of the parent. Is that correct? The array of final matrices has to be in skininfo numbered order. I'm not sure that your hierarchy necessarily matches. You can check that using skinfo-GetBoneName(boneNumber) and checking your bonename-vs-bonenumber.

This was a problem, yes, but I solved it already. It is not directly related to portion of code I showed - the skininfo-bone order appears to only matter for what I supply to the shader. I still have to update the hierachy like I did in my code in frame-order, and for supplying the final matrices to the shader, I sort the matrices by the bone names from the skinInfo. The animation is working nicely that way, using the skininfo-offset-matrices, yet I still wonder what DirectX does differently to me to calculate their offset matrices. Do I maybe need to take the skininfo-order into account instead of the frame-hierachy for calculating the matrix here as well? (I wouldn't know how, though...)

Ah, thank you very much for testing it out and explaining it to me! But if I understand this correctly, it means that I pretty much have no choice than to store the offset-matrices, since I want to support conversion from multiple file formats and not just x-files, and from what I get this is just how x-files handle things. Or am I mistaken and the "boneOffset = mesh to-root frame transform * calculated bone offset" is a general thing that every/most mesh formats would require for correct skinning?