Loading non-skeletal animation to opengl via assimp

Question

I'm a newbie in assimp and openGL. I'm trying to import .fbx or .dae formatted file to openGL via assimp. Importing skeletal animation was kind of easy. Lots of introductions and sample projects helped me to run several files properly. But, in case of none skeletal animation(does it named 'vertex animation'?), which has no bone, I can't find any of source, instructions, including assimp tutorials. Or, I'm not sure it is even possible, maybe assimp doesn't support this kind of animation. Is there any recommendable project for non skeletal animation? Any single comment, will be helpful. Thanks.

Answer 1

It is actually easier than you think. The way this works is really simple, it is a lot like video.

So, when you watch a video(I am sure you know this already but just as a reminder) you are not actually watching a moving image, instead you are watch a lot of images getting displayed one after the other REALLY fast, faster than your eye can see(There is a video from gamespot called "Do we need 60 fps" if you are interested).

Non-skeletal animation works in the same way. Let's say you have an animation with 240 frames, and each frame is a file in a directory. Let's also say that your computer runs at 60 fps. All you have to do is, for every next frame load the next model frame and draw that. In simple words, each time you draw to the screen you move to the next model frame.

But, this is only if you are running at 60fps. If you are running at lower fps, like 30fps, the animation will appear to slow down. I will not explain this a lot because since you have already done skeletal animation, I assume that you have dealt with this problem. Solution: find out have much time has passed since the last frame and if that is bigger than the time that each animation frame takes, move to the next frame. Some thing like this:

 int framesToMove = (int)((lastFrameTime - currentFrameTime) / animFrameTime)

If you do not understand, ask me.

Advantage: A lot more performance friendly, than skeletal animation.

Disadvantage: Requires A LOT more memory.

Recommendation: Use skeletal animation for complicated animations, like character movement, and for animation with complicated models that have many vertices, and use non-skeletal animation for simpler models, like a gate opening animation.

Here is some example code:

#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>

Assimp::Importer importer;

const aiScene* scene = importer.ReadFile(("./res/models/" + fileName).c_str(), aiProcess_Triangulate | aiProcess_GenSmoothNormals |  aiProcess_FlipUVs |  aiProcess_CalcTangentSpace);

if(!scene) {
    std::cout << "Mesh load failed!" << std::endl;
}

const aiMesh* model = scene->mMeshes[0];

std::vector<Vector3f> positions;
std::vector<Vector2f> texCoords;
std::vector<Vector3f> normals;
std::vector<Vector3f> tangents;
std::vector<unsigned int> indices;

for(unsigned int i = 0; i < model->mNumVertices; i++) {
    const aiVector3D pos = model->mVertices[i];
    const aiVector3D normal = model->mNormals[i];
    const aiVector3D texCoord = model->HasTextureCoords(0) ? model->mTextureCoords[0][i] : aiVector3D(0.0f, 0.0f, 0.0f);
    const aiVector3D tangent = model->mTangents[i];

    positions.push_back(Vector3f(pos.x, pos.y, pos.z));
    texCoords.push_back(Vector2f(texCoord.x, texCoord.y));
    normals.push_back(Vector3f(normal.x, normal.y, normal.z));
    tangents.push_back(Vector3f(tangent.x, tangent.y, tangent.z));
}

for(unsigned int i = 0; i < model->mNumFaces; i++) {
    const aiFace& face = model->mFaces[i];
    assert(face.mNumIndices == 3);
    indices.push_back(face.mIndices[0]);
    indices.push_back(face.mIndices[1]);
    indices.push_back(face.mIndices[2]);
}