vrshoot: c179c72369be libs/assimp/OgreSkeleton.cpp

314 if(Animations.size()>0)//Maybe the model had only a skeleton and no animations. (If it also has no skeleton, this function would'nt have been called

315 {

316 m_CurrentScene->mNumAnimations=Animations.size();

317 m_CurrentScene->mAnimations=new aiAnimation*[Animations.size()];

318 for(unsigned int i=0; i<Animations.size(); ++i)//create all animations

319 {

320 aiAnimation* NewAnimation=new aiAnimation();

321 NewAnimation->mName=Animations[i].Name;

322 NewAnimation->mDuration=Animations[i].Length;

323 NewAnimation->mTicksPerSecond=1.0f;

324

325 //Create all tracks in this animation

326 NewAnimation->mNumChannels=Animations[i].Tracks.size();

327 NewAnimation->mChannels=new aiNodeAnim*[Animations[i].Tracks.size()];

328 for(unsigned int j=0; j<Animations[i].Tracks.size(); ++j)

329 {

330 aiNodeAnim* NewNodeAnim=new aiNodeAnim();

331 NewNodeAnim->mNodeName=Animations[i].Tracks[j].BoneName;

332

333 //we need this, to acces the bones default pose, which we need to make keys absolute to the default bone pose

334 vector<Bone>::const_iterator CurBone=find(Bones.begin(), Bones.end(), NewNodeAnim->mNodeName);

335 aiMatrix4x4 t0, t1;

336 aiMatrix4x4 DefBonePose=aiMatrix4x4::Translation(CurBone->Position, t1)

337 * aiMatrix4x4::Rotation(CurBone->RotationAngle, CurBone->RotationAxis, t0);

338

339

340 //Create the keyframe arrays...

341 unsigned int KeyframeCount=Animations[i].Tracks[j].Keyframes.size();

342 NewNodeAnim->mNumPositionKeys=KeyframeCount;

343 NewNodeAnim->mNumRotationKeys=KeyframeCount;

344 NewNodeAnim->mNumScalingKeys =KeyframeCount;

345 NewNodeAnim->mPositionKeys=new aiVectorKey[KeyframeCount];

346 NewNodeAnim->mRotationKeys=new aiQuatKey[KeyframeCount];

347 NewNodeAnim->mScalingKeys =new aiVectorKey[KeyframeCount];

348

349 //...and fill them

350 for(unsigned int k=0; k<KeyframeCount; ++k)

351 {

352 aiMatrix4x4 t2, t3;

353

354 //Create a matrix to transfrom a vector from the bones default pose to the bone bones in this animation key

355 aiMatrix4x4 PoseToKey=

356 aiMatrix4x4::Translation(Animations[i].Tracks[j].Keyframes[k].Position, t3) //pos

357 * aiMatrix4x4(Animations[i].Tracks[j].Keyframes[k].Rotation.GetMatrix()) //rot

358 * aiMatrix4x4::Scaling(Animations[i].Tracks[j].Keyframes[k].Scaling, t2); //scale

359

360

361 //calculate the complete transformation from world space to bone space

362 aiMatrix4x4 CompleteTransform=DefBonePose * PoseToKey;

363

364 aiVector3D Pos;

365 aiQuaternion Rot;

366 aiVector3D Scale;

367

368 CompleteTransform.Decompose(Scale, Rot, Pos);

369

370 double Time=Animations[i].Tracks[j].Keyframes[k].Time;

371

372 NewNodeAnim->mPositionKeys[k].mTime=Time;

373 NewNodeAnim->mPositionKeys[k].mValue=Pos;

374

375 NewNodeAnim->mRotationKeys[k].mTime=Time;

376 NewNodeAnim->mRotationKeys[k].mValue=Rot;

377

378 NewNodeAnim->mScalingKeys[k].mTime=Time;

379 NewNodeAnim->mScalingKeys[k].mValue=Scale;

380 }

381

382 NewAnimation->mChannels[j]=NewNodeAnim;

383 }

384

385 m_CurrentScene->mAnimations[i]=NewAnimation;

386 }

387 }

388 //TODO: Auf nicht vorhandene Animationskeys achten!

389 //#pragma warning (s.o.)

390 //__________________________________________________________________

391 }

392

393

394 aiNode* OgreImporter::CreateAiNodeFromBone(int BoneId, const std::vector<Bone> &Bones, aiNode* ParentNode)

395 {

396 //----Create the node for this bone and set its values-----

397 aiNode* NewNode=new aiNode(Bones[BoneId].Name);

398 NewNode->mParent=ParentNode;

399

400 aiMatrix4x4 t0,t1;

401 NewNode->mTransformation=

402 aiMatrix4x4::Translation(Bones[BoneId].Position, t0)

403 *aiMatrix4x4::Rotation(Bones[BoneId].RotationAngle, Bones[BoneId].RotationAxis, t1)

404 ;

405 //__________________________________________________________

406

407

408 //---------- recursivly create all children Nodes: ----------

409 NewNode->mNumChildren=Bones[BoneId].Children.size();

410 NewNode->mChildren=new aiNode*[Bones[BoneId].Children.size()];

411 for(unsigned int i=0; i<Bones[BoneId].Children.size(); ++i)

412 {

413 NewNode->mChildren[i]=CreateAiNodeFromBone(Bones[BoneId].Children[i], Bones, NewNode);

414 }

415 //____________________________________________________

416

417

418 return NewNode;

419 }

420

421

422 void Bone::CalculateBoneToWorldSpaceMatrix(vector<Bone> &Bones)

423 {

424 //Calculate the matrix for this bone:

425

426 aiMatrix4x4 t0,t1;

427 aiMatrix4x4 Transf= aiMatrix4x4::Rotation(-RotationAngle, RotationAxis, t1)

428 * aiMatrix4x4::Translation(-Position, t0);

429

430 if(-1==ParentId)

431 {

432 BoneToWorldSpace=Transf;

433 }

434 else

435 {

436 BoneToWorldSpace=Transf*Bones[ParentId].BoneToWorldSpace;

437 }

438

439

440 //and recursivly for all children:

441 BOOST_FOREACH(int theChildren, Children)

442 {

443 Bones[theChildren].CalculateBoneToWorldSpaceMatrix(Bones);

444 }

445 }

446

447

448 }//namespace Ogre

449 }//namespace Assimp

450

451 #endif // !! ASSIMP_BUILD_NO_OGRE_IMPORTER