I am attempted to play an animation created in blender inside my openGL program. First of all, i wrote a custom python exporter to convert to a custom format. It is similar to .obj, except the it also stores bone hierarchy, vertex weight influences, as well keyframes and bone transformation matrices per keyframe. (And it also uses raw data). I know my python exporter and c++ importer do everything correctly, except the bone matrices. The animation is wrong, so either i am exporting the wrong matrices from blender, or there is something wrong with my opengl/glsl code to render it.
My python code to export the matrix is basically this (from what i gathered browsing stack exchange it should be correct):
for i in list_of_frames:
...
bpy.context.scene.frame_set(i) #set this as the current frame in blender
for bone in arm.pose.bones: #loop through bones
mat = bone.matrix_basis
...
for m in range(4): #write matrix to file. Note that blender matrices are row-major and i write it in the form <row1><row2>etc.
fw(struct.pack('f',mat[m][0]))
fw(struct.pack('f',mat[m][1]))
fw(struct.pack('f',mat[m][2]))
fw(struct.pack('f',mat[m][3]))
My c++ code to read it goes like this:
glm::mat4 mat;
for (int y = 0; y < 4; y++) {
for (int x = 0; x < 4; x++) {
dataToFloat(buffer.data() + ptr, &mat[y][x]); //NOT-row-major
ptr += 4;
}
}
glm::rotate(mat, -3.14f / 2.f, glm::vec3(1.0f, 0.0f, 0.0f));
glm::scale(mat, glm::vec3(0, -1, 0)); //use openGL coordinate system
Now, other then the code to convert blender->openGL coordinate system, i know it copies the data correctly, but either my python exporter is giving it the wrong data or the c++ renderer is using it wrong.
A ‘keyframe’ is stored as a time stamp and a list of matrices, for each bone:
struct KeyFrame {
float time;
std::vector<glm::mat4> mat4s; //stores the matrices for each bone at this keyframe.
};
And a bone is just:
struct Bone {
std::vector<int> children;
Bone* parent;
int id;
glm::mat4 matrix; //doesnt store data between frames, temporary calculations
};
Now, my this is my renderer; note that an ‘AnimationMesh’ is a collection of vertices, normals, vertex weights, etc plus a bone hierarchy, and a ‘Animation’ is a list of keyframes:
//used to recursively calculate a bone's final matrix:
glm::mat4 calcMatrix(Bone* bone) {
if (bone->parent == NULL) {
return bone->matrix;
}
else {
return calcMatrix(bone->parent)* bone->matrix;
}
}
void RenderAnimation(AnimationMesh* aM, Animation* anim, float delta, GLuint shader) {
//make sure current time is in bounds
if (anim->time >= anim->keyFrames.back().time) {
anim->time = anim->keyFrames[0].time;
}
if (anim->time < anim->keyFrames[0].time) {
anim->time = anim->keyFrames[0].time;
}
//find the previous and next keyframe for the current time
KeyFrame *start = NULL, *stop = NULL;
for (int i = 0; i < anim->keyFrames.size(); i++) {
if (anim->time >= anim->keyFrames[i].time) {
if (anim->time < anim->keyFrames[i + 1].time) {
start = &anim->keyFrames[i];
stop = &anim->keyFrames[i + 1];
break;
}
}
}
calculate a value used for interpolating between previous and next keyframe.
float inter = (anim->time - start->time) / (stop->time - start->time);
for (int i = 0; i < aM->Hierarchy.size(); i++) {
//for each bone, interpolate between the matrices of the bone at the previous and next keyframe. Store this to the corresponding bone's matrix.
aM->Hierarchy[i].matrix = glm::mat4_cast(glm::slerp(glm::quat_cast(start->mat4s[i]), glm::quat_cast(stop->mat4s[i]), inter));
}
//calculate each bone's final matrix (that will be sent to shader) by multiplying it by the bone's parent's matrices recursively (see function above).
std::vector<glm::mat4> mat4out(aM->Hierarchy.size());
for (int i = 0; i < aM->Hierarchy.size(); i++) {
mat4out[i] = calcMatrix(&aM->Hierarchy[i]);
}
//upload to shader
glUniformMatrix4fv(glGetUniformLocation(shader, "boneMats"), mat4out.size(), GL_FALSE, glm::value_ptr(mat4out[0]));
//increment time
anim->time += delta;
//bind VBOs and render it
RenderAnimationMeshStatic(aM, shader);
}
https://imgur.com/a/bHbFe shows how the animation looks in my program vs how it looks in blender.
I have not been able to solve this for a week so any ideas as to what i am doing wrong will be appreciated 