Add "node" to the list of synonyms. Assimp uses the term node.

Assimp also uses bones. (aiBone structure)

Still having problems with the matrices.

Am I supposed to multiply each node's mTransformation matrix by its parents' matrices, in order to get (and store) the "toRoot" matrix? cause that's what I'm doing, and I'm not sure if I'm getting correct results. (still static models)

Here's what I've done so far:

The main "Scene" class is called Model. It has a vector of Node objects, and each node has a vector of Mesh objects.

Each node also stores a glm::mat4 matrix (column-major) called toRoot. Some code:

//model.cpp

bool Model::import(const char *file)
{
	_scene = aiImportFile(file, aiProcess_Triangulate | 0/*aiProcess_FlipUVs*/);
	if(!_scene)
		aeError("could not load 3d model");

	return (_scene != nullptr);
}

void Model::load()
{
	if(_scene)
		_processNode(_scene->mRootNode, aiMatrix4x4()) //call _processNode with an identity matrix
}

void Model::draw()
{
	if(_scene)
		for(size_t i = 0; i < _nodes.size(); i++)
		{
			_shaderProgram.setUniform("ModelMatrix",  _transformation * _nodes[i].toRoot()); //_transformation is a private glm::mat4 that I use for scaling the model if it's too big.
			_nodes[i].draw();
		}
}

void Model::_processNode(aiNode *node, aiMatrix4x4 toRoot)
{
	_nodes.push_back( Node(node, _scene, toRoot, &_meshOptions) );

	for(unsigned int i = 0; i < node->mNumChildren; i++)
		_processNode(node->mChildren[i], node->mTransformation * toRoot); //aiMatrix4x4 is row-major, so I think this order of multiplication is correct
}


//node.cpp

Node::Node(aiNode *node, const aiScene *scene, aiMatrix4x4 toRoot, MeshOptions *meshOptions) : _node(node), _scene(scene)
{
	_aiMatrixToGlm(toRoot, _toRoot); //just inverses the give aiMatrix, and copies it to _toRoot.

	for(unsigned int i = 0; i < _node->mNumMeshes; i++)
	{
		unsigned int meshIndex = node->mMeshes[i];
		_meshes.push_back( Mesh(_scene->mMeshes[meshIndex], meshOptions) );
	}
}

void Node::draw()
{
	for(size_t i = 0; i < _meshes.size(); i++)
		_meshes[i].draw();
}

//private help function
void Node::_aiMatrixToGlm(const aiMatrix4x4 &aiMat, glm::mat4 &glmMat)
{
	//inverse from row-major to column-major
	aiMatrix4x4 temp = aiMat;
	temp.Inverse();

	for(int i = 0; i < 4; i++)
		for(int j = 0; j < 4; j++)
			glmMat[i][j] = temp[i][j];
}

in main.cpp, I first call Model::import(), then Model::load(), and then in the render function I call Model::draw().

The Mesh class constructor just uploads aiMesh data to the gpu using OpenGL functions. Mesh::draw() simply calls glDrawElements().

What am I doing wrong?

I noticed that when playing with the matrix calculations (in example changing the multiplication order, or simply omitting prog.setUniform() line) I get the same results. (the barbarian is located in the same spot everytime). This makes me think that my code is buggy.

So my question is if I'm doing this right, storing in each node a "toRoot" matrix which is the multiplication of the node mTransformation matrix and all of its parents' mTransformation matrices.

Add "node" to the list of synonyms. Assimp uses the term node.

Assimp also uses bones. (aiBone structure)

So I got some stuff working now. I managed to display good looking (still static) models using the nodes' hierarchy and their toRoot matrix.

I've been trying for days to figure out the offset matrix purpose and how to generate one for every bone. (just so I know I got it right. Assimp generates an offset matrix for every bone automatically).

Please correct me if I'm wrong in any of the next statements:

1. From what I've read, the offset matrix transforms vertices from their mesh node space to their influence bone space. a simpler explanation: it transforms vertices from their node space to the bone's node space. By that, the offset matrix calculation should be like this:

//using the opengl matrix multiplication order (right is first, left is second)
offsetMatrix = Inverse(boneNode.toRoot()) * meshNode.toRoot(); 

2. Having the toRoot matrix for every node is enough in order to display a static model. No other data like the offset matrix is needed.

Regarding the first statement, I checked if the offset matrix calculated by Assimp is equal to the offset matrix I calculate with my approach. I failed.

Here's my attempt:

aiBone *bone = mesh->mBones[i];
			 
cout << "bone->mName.C_Str(): " << bone->mName.C_Str() << endl;
cout << "bone->mOffsetMatrix:\n";
disp(bone->mOffsetMatrix); //displays a given matrix

aiNode *boneNode = findNodeByName(bone->mName.C_Str());
if(boneNode == nullptr)
	cout << "findNodeByName(bone->mName.C_Str()) is nullptr\n";
else {
	aiMatrix4x4 nodeToRoot = calcToRoot(meshNode);
	aiMatrix4x4 boneToRoot = calcToRoot(boneNode);

	cout << "my calculated offset matrix:\n";
	disp(boneToRoot.Inverse() * nodeToRoot);
}

Here's the whole piece of code, if it helps. (not too long)

Note that I also tried playing with the matrices multiplication order. offsetMatrix is still not close to be the assimp's bone offset matrix.

Help would be greatly appreciated!

The description is correct. However, it may be that the assimp offset matrix is just boneToRoot.Invervse(). Have you made that comparision?

I tried comparing the matrices and they are still different. Can anyone who worked with Assimp before confirm what exactly does assimp's offsetMatrix do? It isn't equal to any matrix transformation I tested till now.

Two more questions regarding the "final matrix":

1. Let's say that assimp's offset matrix for each bones transforms from root node space to bone space ( Inverse(boneToRoot) ). The final matrix for each bone in the render cycle should be the following: Inverse(offsetMatrix) * animationMatrix * offsetMatrix * nodeToRoot. In order words:

Mesh node space -> root node space,

root node space -> bone node space,

apply the animation matrix, so: bone node space -> animated bone node space.

now back to root space: animated bone node space -> (animated) root node space.

Is this correct?

2. Many people suggest to extract only the "bone nodes" from the node hierarchy and upload them to a Skeleton object which contains only bones.

When calculating the final matrix for each bone (the only that will be uploaded to the shader), should I care about bones only or should I care about nodes (that might be under the bones in the node hierarchy) too?

What's the preferred way of doing this?