start of Animation/mainwidget.cpp

A5/Animation/mainwidget.cpp

@@ -2,7 +2,7 @@
 
 MainWidget::MainWidget()
 {
-
+    startTime = QTime::currentTime();
 }
 
 QSize MainWidget::minimumSizeHint() const
@@ -104,7 +104,9 @@ void MainWidget::paintGL(){
     animationShader->setUniformValue("colorTexture",0);
     animationShader->setUniformValue("LightPos",QVector3D(0,100,100));
 
-    mesh->render(animationShader,m_view*rot, m_projection);
+    time = startTime.msecsTo(QTime::currentTime()) /1000.0;
+
+    mesh->render(animationShader,m_view*rot, m_projection,(float) time);
 
     animationShader->release();
     update();

A5/Animation/mainwidget.h

@@ -35,6 +35,7 @@ private:
         QOpenGLShaderProgram* animationShader;
         QMatrix4x4 m_projection;
         QMatrix4x4 m_view;
+        QTime startTime;
 
         float camDistance;
 

A5/Animation/mesh.cpp

@@ -284,8 +284,14 @@ void Mesh::updateBoneTransform(float TimeInSeconds){
     if(!scene)
         return;
     const aiAnimation* animation = scene->mAnimations[0];
+
+
+    float TicksPerSecond = (float)(animation->mTicksPerSecond != 0 ? animation->mTicksPerSecond : 25.0f);
+    float TimeInTicks = TimeInSeconds * TicksPerSecond;
+    float AnimationTime = fmod(TimeInTicks, (float)animation->mDuration);
+
     //TODO calc time and get Anaimation;
-    updateBoneHeirachy(0.0,animation,this->rootNode,QMatrix4x4());
+    updateBoneHeirachy(AnimationTime,animation,this->rootNode,QMatrix4x4());
 
 
 
@@ -345,28 +351,81 @@ const aiNodeAnim* Mesh::findAnimOfNode(const aiAnimation* animation, QString Nod
 
 
 QVector3D Mesh::calcInterpolatedScaling(float AnimTime,const aiNodeAnim *nodeAnimation){
-    int index = nodeAnimation->mNumScalingKeys/2;
-    //index = 0;
-    aiVector3D scale = nodeAnimation->mScalingKeys[index].mValue;
-    return QVector3D(scale.x,scale.y,scale.z);
+    if(nodeAnimation->mNumScalingKeys == 1){
+        return convert(nodeAnimation->mScalingKeys[0].mValue);
+    }
+
+    //Index find
+    int index = 0;
+    for (uint i = 0 ; i < nodeAnimation->mNumScalingKeys - 1; i++) {
+        if (AnimTime < (float)nodeAnimation->mScalingKeys[i + 1].mTime) {
+            index = i;
+            break;
+        }
+    }
+
+     float DeltaTime = (float)(nodeAnimation->mScalingKeys[index+1].mTime - nodeAnimation->mScalingKeys[index].mTime);
+     float Factor = (AnimTime - (float)nodeAnimation->mScalingKeys[index].mTime) / DeltaTime;
+
+     QVector3D start = convert(nodeAnimation->mScalingKeys[index].mValue);
+     QVector3D end = convert(nodeAnimation->mScalingKeys[index+1].mValue);
+
+    return linInterpolate(start,end,Factor);
 }
 
 QQuaternion Mesh::calcInterpolatedRotation(float AnimTime,const aiNodeAnim *nodeAnimation){
-    int index = nodeAnimation->mNumRotationKeys/2;
-   // index = 0;
-    aiQuaternion quat = nodeAnimation->mRotationKeys[index].mValue;
-     return QQuaternion(quat.w,quat.x,quat.y,quat.z);
+    if(nodeAnimation->mNumRotationKeys == 1){
+        return convert(nodeAnimation->mRotationKeys[0].mValue);
+    }
+
+    //Index find
+    int index = 0;
+    for (uint i = 0 ; i < nodeAnimation->mNumRotationKeys - 1 ; i++) {
+        if (AnimTime < (float)nodeAnimation->mRotationKeys[i + 1].mTime) {
+            index = i;
+            break;
+        }
+    }
+
+    float DeltaTime = (float)(nodeAnimation->mRotationKeys[index+1].mTime - nodeAnimation->mRotationKeys[index].mTime);
+    float Factor = (AnimTime - (float)nodeAnimation->mRotationKeys[index].mTime) / DeltaTime;
+   // qDebug()<<AnimTime<<DeltaTime<<Factor;
+
+    const aiQuaternion start = nodeAnimation->mRotationKeys[index].mValue;
+    const aiQuaternion end = nodeAnimation->mRotationKeys[index+1].mValue;
+
+    aiQuaternion RotationQ;
+    aiQuaternion::Interpolate(RotationQ,start,end,Factor);
+   return convert(RotationQ);
+   //return convert(start);
 }
 
 QVector3D Mesh::calcInterpolatedTranslation(float AnimTime, const aiNodeAnim *nodeAnimation){
-    int index = nodeAnimation->mNumScalingKeys/2;
-   // index = 0;
-     aiVector3D pos = nodeAnimation->mPositionKeys[index].mValue;
-    return QVector3D(pos.x,pos.y,pos.z);
+    if(nodeAnimation->mNumPositionKeys == 1){
+        convert(nodeAnimation->mPositionKeys[0].mValue);
+    }
+
+    //Index find
+    int index = 0;
+    for (uint i = 0 ; i < nodeAnimation->mNumPositionKeys - 1 ; i++) {
+        if (AnimTime < (float)nodeAnimation->mPositionKeys[i + 1].mTime) {
+            index = i;
+            break;
+        }
+    }
+
+
+    float DeltaTime = (float)(nodeAnimation->mPositionKeys[index+1].mTime - nodeAnimation->mPositionKeys[index].mTime);
+    float Factor = (AnimTime - (float)nodeAnimation->mPositionKeys[index].mTime) / DeltaTime;
+
+    QVector3D start = convert(nodeAnimation->mPositionKeys[index].mValue);
+    QVector3D end = convert(nodeAnimation->mPositionKeys[index+1].mValue);
+
+   return linInterpolate(start,end,Factor);
 }
 
 
-void Mesh::render(QOpenGLShaderProgram *shader, QMatrix4x4 V,QMatrix4x4 P){
+void Mesh::render(QOpenGLShaderProgram *shader, QMatrix4x4 V,QMatrix4x4 P, float TimeInSeconds){
     if(!loaded)
         return;
     if(f == NULL){
@@ -381,7 +440,7 @@ void Mesh::render(QOpenGLShaderProgram *shader, QMatrix4x4 V,QMatrix4x4 P){
     f->glEnableVertexAttribArray(boneweightIndex);
 
 
-    updateBoneTransform(0.0);
+    updateBoneTransform(TimeInSeconds);
     QVector<QMatrix4x4> boneTransforms = QVector<QMatrix4x4>(bones.size());
     for(int i = 0; i < bones.size(); i++){
         boneTransforms[i] = bones[i].FinalTransformation;

A5/Animation/mesh.h

@@ -47,7 +47,7 @@ public:
 
 
 
-    void render(QOpenGLShaderProgram *shader, QMatrix4x4 V,QMatrix4x4 P);
+    void render(QOpenGLShaderProgram *shader, QMatrix4x4 V,QMatrix4x4 P, float TimeInSeconds);
 
 private:
 
@@ -138,6 +138,11 @@ private:
     void renderNode(QOpenGLShaderProgram *shader, Node &node, QMatrix4x4 V,QMatrix4x4 P,QMatrix4x4 M);
     void renderMesh(QOpenGLShaderProgram *shader, int index);
 
+    QVector3D convert(aiVector3D in){ return QVector3D(in.x,in.y,in.z);}
+    QQuaternion convert(aiQuaternion quat){ return QQuaternion(quat.w,quat.x,quat.y,quat.z);}
+    QVector3D linInterpolate(QVector3D start, QVector3D end, float Factor){ return (1.0-Factor)*start + Factor*end;}
+
+
 };
 
 #endif // MESH_H