From d035441876e9678093f89e4f46bcfa820333549b Mon Sep 17 00:00:00 2001 From: Jason Hooks Date: Mon, 11 Apr 2011 20:56:06 -0400 Subject: [PATCH] Reintroducing animation --- components/nif/data.hpp | 242 ++++++++++++++++++++++--- components/nifogre/ogre_nif_loader.cpp | 165 +++++++++++++++++ components/nifogre/ogre_nif_loader.hpp | 4 + 3 files changed, 390 insertions(+), 21 deletions(-) diff --git a/components/nif/data.hpp b/components/nif/data.hpp index 6fc2c4b820..bc23c45abe 100644 --- a/components/nif/data.hpp +++ b/components/nif/data.hpp @@ -25,6 +25,8 @@ #define _NIF_DATA_H_ #include "controlled.hpp" +#include +#include namespace Nif { @@ -433,20 +435,91 @@ public: class NiKeyframeData : public Record { + + //Rotations + std::vector quats; + std::vector tbc; + std::vector rottime; + int rtype; + + //Translations + std::vector translist1; + std::vector translist2; + std::vector translist3; + std::vector transtbc; + std::vector transtime; + int ttype; + + //Scalings + + std::vector scalefactor; + std::vector scaletime; + std::vector forwards; + std::vector backwards; + std::vector tbcscale; + int stype; + public: + void read(NIFFile *nif) { // Rotations first int count = nif->getInt(); + //std::vector quat(count); + //std::vector rottime(count); + std::cout << "r"; if(count) { - int type = nif->getInt(); - if(type == 1) - nif->skip(count*4*5); // time + quaternion - else if(type == 3) - nif->skip(count*4*8); // rot1 + tension+bias+continuity - else if(type == 4) + //TYPE1 LINEAR_KEY + //TYPE2 QUADRATIC_KEY + //TYPE3 TBC_KEY + //TYPE4 XYZ_ROTATION_KEY + //TYPE5 UNKNOWN_KEY + rtype = nif->getInt(); + //std::cout << "Count: " << count << "Type: " << type << "\n"; + + if(rtype == 1) + { + //We need to actually read in these values instead of skipping them + //nif->skip(count*4*5); // time + quaternion + for (int i = 0; i < count; i++) { + float time = nif->getFloat(); + float w = nif->getFloat(); + float x = nif->getFloat(); + float y = nif->getFloat(); + float z = nif->getFloat(); + Ogre::Quaternion quat = Ogre::Quaternion(Ogre::Real(w), Ogre::Real(x), Ogre::Real(y), Ogre::Real(z)); + quats.push_back(quat); + rottime.push_back(time); + //if(time == 0.0 || time > 355.5) + // std::cout <<"Time:" << time << "W:" << w <<"X:" << x << "Y:" << y << "Z:" << z << "\n"; + } + } + else if(rtype == 3) + { //Example - node 116 in base_anim.nif + for (int i = 0; i < count; i++) { + float time = nif->getFloat(); + float w = nif->getFloat(); + float x = nif->getFloat(); + float y = nif->getFloat(); + float z = nif->getFloat(); + + float tbcx = nif->getFloat(); + float tbcy = nif->getFloat(); + float tbcz = nif->getFloat(); + Ogre::Quaternion quat = Ogre::Quaternion(Ogre::Real(w), Ogre::Real(x), Ogre::Real(y), Ogre::Real(z)); + Ogre::Vector3 vec = Ogre::Vector3(tbcx, tbcy, tbcz); + quats.push_back(quat); + rottime.push_back(time); + tbc.push_back(vec); + //if(time == 0.0 || time > 355.5) + // std::cout <<"Time:" << time << "W:" << w <<"X:" << x << "Y:" << y << "Z:" << z << "\n"; + } + + //nif->skip(count*4*8); // rot1 + tension+bias+continuity + } + else if(rtype == 4) { for(int j=0;jfail("Unknown rotation type in NiKeyframeData"); } + //first = false; // Then translation count = nif->getInt(); + if(count) { - int type = nif->getInt(); - - if(type == 1) nif->getFloatLen(count*4); // time + translation - else if(type == 2) - nif->getFloatLen(count*10); // trans1 + forward + backward - else if(type == 3) - nif->getFloatLen(count*7); // trans1 + tension,bias,continuity + ttype = nif->getInt(); + + //std::cout << "TransCount:" << count << " Type: " << type << "\n"; + if(ttype == 1) { + for (int i = 0; i < count; i++) { + float time = nif->getFloat(); + float x = nif->getFloat(); + float y = nif->getFloat(); + float z = nif->getFloat(); + Ogre::Vector3 trans = Ogre::Vector3(x, y, z); + translist1.push_back(trans); + transtime.push_back(time); + } + //nif->getFloatLen(count*4); // time + translation + } + else if(ttype == 2) + { //Example - node 116 in base_anim.nif + for (int i = 0; i < count; i++) { + float time = nif->getFloat(); + float x = nif->getFloat(); + float y = nif->getFloat(); + float z = nif->getFloat(); + float x2 = nif->getFloat(); + float y2 = nif->getFloat(); + float z2 = nif->getFloat(); + float x3 = nif->getFloat(); + float y3 = nif->getFloat(); + float z3 = nif->getFloat(); + Ogre::Vector3 trans = Ogre::Vector3(x, y, z); + Ogre::Vector3 trans2 = Ogre::Vector3(x2, y2, z2); + Ogre::Vector3 trans3 = Ogre::Vector3(x3, y3, z3); + transtime.push_back(time); + translist1.push_back(trans); + translist2.push_back(trans2); + translist3.push_back(trans3); + } + + //nif->getFloatLen(count*10); // trans1 + forward + backward + } + else if(ttype == 3){ + for (int i = 0; i < count; i++) { + float time = nif->getFloat(); + float x = nif->getFloat(); + float y = nif->getFloat(); + float z = nif->getFloat(); + float t = nif->getFloat(); + float b = nif->getFloat(); + float c = nif->getFloat(); + Ogre::Vector3 trans = Ogre::Vector3(x, y, z); + Ogre::Vector3 tbc = Ogre::Vector3(t, b, c); + translist1.push_back(trans); + transtbc.push_back(tbc); + transtime.push_back(time); + } + //nif->getFloatLen(count*7); // trans1 + tension,bias,continuity + } else nif->fail("Unknown translation type"); } @@ -484,17 +608,93 @@ public: count = nif->getInt(); if(count) { - int type = nif->getInt(); - - int size = 0; - if(type == 1) size = 2; // time+scale - else if(type == 2) size = 4; // 1 + forward + backward (floats) - else if(type == 3) size = 5; // 1 + tbc - else nif->fail("Unknown scaling type"); - nif->getFloatLen(count*size); + stype = nif->getInt(); + + + for(int i = 0; i < count; i++){ + + + //int size = 0; + if(stype >= 1 && stype < 4) + { + float time = nif->getFloat(); + float scale = nif->getFloat(); + scaletime.push_back(time); + scalefactor.push_back(scale); + //size = 2; // time+scale + } + else nif->fail("Unknown scaling type"); + if(stype == 2){ + //size = 4; // 1 + forward + backward (floats) + float forward = nif->getFloat(); + float backward = nif->getFloat(); + forwards.push_back(forward); + backwards.push_back(backward); + } + else if(stype == 3){ + float tbcx = nif->getFloat(); + float tbcy = nif->getFloat(); + float tbcz = nif->getFloat(); + Ogre::Vector3 vec = Ogre::Vector3(tbcx, tbcy, tbcz); + tbcscale.push_back(vec); + + //size = 5; // 1 + tbc + } + + } } + else + stype = 0; } + int getRtype(){ + return rtype; + } + int getStype(){ + return stype; + } + int getTtype(){ + return ttype; + } + std::vector getQuat(){ + return quats; + } + std::vector getrTbc(){ + return tbc; + } + std::vector getrTime(){ + return rottime; + } + + std::vector getTranslist1(){ + return translist1; + } + std::vector getTranslist2(){ + return translist2; + } + std::vector getTranslist3(){ + return translist3; + } + std::vector gettTime(){ + return transtime; + } + std::vector getScalefactor(){ + return scalefactor; + } + std::vector getForwards(){ + return forwards; + } + std::vector getBackwards(){ + return backwards; + } + std::vector getScaleTbc(){ + return tbcscale; + } + + std::vector getsTime(){ + return scaletime; + } }; + } // Namespace #endif diff --git a/components/nifogre/ogre_nif_loader.cpp b/components/nifogre/ogre_nif_loader.cpp index a33fde55ad..3d63a9f989 100644 --- a/components/nifogre/ogre_nif_loader.cpp +++ b/components/nifogre/ogre_nif_loader.cpp @@ -1068,6 +1068,11 @@ void NIFLoader::loadResource(Resource *resource) // Handle the node handleNode(node, 0, NULL, bounds, 0); + + short handle = 0; + //skel->setBlendMode(Ogre::SkeletonAnimationBlendMode::ANIMBLEND_CUMULATIVE); + bool first = true; + // set the bounding value. if (bounds.isValid()) { @@ -1075,6 +1080,166 @@ void NIFLoader::loadResource(Resource *resource) bounds.maxX(), bounds.maxY(), bounds.maxZ())); mesh->_setBoundingSphereRadius(bounds.getRadius()); } + for(int i = 0; i < nif.numRecords(); i++) + { + + Nif::NiKeyframeController *f = dynamic_cast(nif.getRecord(i)); + Nif::Node *n = dynamic_cast(nif.getRecord(i)); + + + if(f != NULL) + { + Nif::NiKeyframeDataPtr data = f->data; + std::cout << "Controller's Rtype:" << data->getRtype() << "Stype: " << data->getStype() << "Ttype:" << data->getTtype() << "\n"; + + if(first){ + + float end = f->timeStop; + //std::cout <<"Creating WholeThing" << end << "\n"; + + //TRANSLATION + if(!mSkel.isNull()){ + std::cout <<"Creating WholeThing" << end << "\n"; + animcore = mSkel->createAnimation("WholeThing", end); + //animcore->setInterpolationMode(Ogre::Animation::IM_SPLINE); + //animcore->setRotationInterpolationMode(Ogre::Animation::RIM_SPHERICAL); + //animcore2->setRotationInterpolationMode(Ogre::Animation::RIM_LINEAR); + + //ROTATION + animcore2 = mSkel->createAnimation("WholeThing2", end); + //animcore2->setInterpolationMode(Ogre::Animation::IM_SPLINE); + //animcore2->setRotationInterpolationMode(Ogre::Animation::RIM_SPHERICAL); + } + std::cout <<"AFTER"; + first = false; + } + if(animcore && animcore2){ + Nif::Named *node = dynamic_cast ( f->target.getPtr()); + std::cout << "The target rec: " << node->name.toString() << "\n"; + Ogre::NodeAnimationTrack* mTrack = animcore->createNodeTrack(handle, mSkel->getBone(node->name.toString())); + Ogre::NodeAnimationTrack* mTrack2 = animcore2->createNodeTrack(handle++, mSkel->getBone(node->name.toString())); + /* if (node->recType == RC_NiNode) + { + NodeList &list = ((NiNode*)node)->children; + int n = list.length(); + + for (int i = n; i<=n; i++) + { + if(skel->hasBone((list[i]).name.toString())) + mTrack3 = animcore2->createNodeTrack(handle++, skel->getBone((list[i]).name.toString())); + + } + }*/ + + std::vector quats = data->getQuat(); + std::vector::iterator quatIter = quats.begin(); + std::vector rtime = data->getrTime(); + std::vector::iterator rtimeiter = rtime.begin(); + + std::vector ttime = data->gettTime(); + std::vector::iterator ttimeiter = ttime.begin(); + std::vector translist1 = data->getTranslist1(); + std::vector::iterator transiter = translist1.begin(); + std::vector translist2 = data->getTranslist2(); + std::vector::iterator transiter2 = translist2.begin(); + std::vector translist3 = data->getTranslist3(); + std::vector::iterator transiter3 = translist3.begin(); + + + float tleft = 0; + float rleft = 0.0; + float ttotal = 0.0; + float rtotal = 0; + Ogre::TransformKeyFrame* mKey; + Ogre::TransformKeyFrame* mKey2; + float tused = 0.0; + float rused = 0.0; + Ogre::Quaternion lastquat; + Ogre::Vector3 lasttrans; + bool rend = false; + bool tend = false; + Ogre::Quaternion test;// = (skel->getBone(node->name.toString()))->getOrientation(); + for (int j = 0 ; j < ttime.size(); j++) + { + if(data->getTtype() >= 1 && data->getTtype() <= 5) + { + + Ogre::TransformKeyFrame* mKey = mTrack->createNodeKeyFrame(*ttimeiter); + Ogre::Vector3 standard = *transiter; + if(data->getTtype() == 2) + standard = *transiter * *transiter2 * *transiter3; + + mKey->setTranslate(standard);/* + if(mTrack3) + { + Ogre::TransformKeyFrame* mKey3 = mTrack->createNodeKeyFrame(*ttimeiter); + mKey3->setTranslate(standard); + }*/ + //mKey->setRotation(Quaternion::ZERO); + //mKey->setScale(Ogre::Vector3(1,1,1)); + transiter++; //START + transiter2++; + transiter3++; + ttimeiter++; + } + } + for (int j = 0 ; j < rtime.size(); j++) + { + if(data->getRtype() >= 1 && data->getRtype() <= 5) + { + Ogre::TransformKeyFrame* mKey2 = mTrack2->createNodeKeyFrame(*rtimeiter); + test = *quatIter; + + mKey2->setRotation(test); + //mKey2->setTranslate(Ogre::Vector3(0,0,0)); + //mKey2->setScale(Ogre::Vector3(1,1,1)); + quatIter++; + rtimeiter++; + } + } + } + + + + + /* + //mTrack = animcore->createNodeTrack(handle++, skel->getBone(node->name.toString())); + + std::vector stime = data->getsTime(); + std::vector::iterator stimeiter = stime.begin(); + + std::vector sfactor = data->getScalefactor(); + std::vector::iterator sfactoriter = sfactor.begin(); + for (int i = 0 ; i < stime.size(); i++) + { + if(data->getStype() >= 1 && data->getStype() <= 5) + { + Ogre::TransformKeyFrame* mKey = mTrack->createNodeKeyFrame(*stimeiter); + mKey->setScale(Ogre::Vector3(*sfactoriter, *sfactoriter, *sfactoriter)); + + sfactoriter++; + stimeiter++; + } + } + */ + + + } + /* + else if (n != NULL) + { + std::cout << "handle" << handle << "\n"; + //handle++; + }*/ + } + + + + // set skeleton + if (!mSkel.isNull()) + { + mesh->_notifySkeleton(mSkel); + } // set skeleton // if (!skel.isNull()) diff --git a/components/nifogre/ogre_nif_loader.hpp b/components/nifogre/ogre_nif_loader.hpp index 6ab22aa2fa..a619d3a3b2 100644 --- a/components/nifogre/ogre_nif_loader.hpp +++ b/components/nifogre/ogre_nif_loader.hpp @@ -131,6 +131,10 @@ class NIFLoader : Ogre::ManualResourceLoader int counter; int numbers; int stack; + bool anim; + int handle2; + Ogre::Animation* animcore; + Ogre::Animation* animcore2; // pointer to the ogre mesh which is currently build