nel/src/3d/u_skeleton.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "std3d.h"
  18
  19 #include "nel/3d/u_skeleton.h"
  20 #include "nel/3d/u_instance.h"
  21 #include "nel/3d/u_bone.h"
  22 #include "nel/3d/play_list_user.h"
  23 #include "nel/3d/skeleton_model.h"
  24 #include "nel/3d/skeleton_model.h"
  25 #include "nel/3d/mesh_base_instance.h"
  26 #include "nel/misc/hierarchical_timer.h"
  27 #include "nel/3d/scene.h"
  28 #include "nel/3d/shape_bank.h"
  29
  30 #ifdef DEBUG_NEW
  31 #define new DEBUG_NEW
  32 #endif
  33
  34 namespace NL3D
  35 {
  36
  37 H_AUTO_DECL( NL3D_UI_Skeleton )
  38
  39 #define NL3D_HAUTO_UI_SKELETON                                          H_AUTO_USE( NL3D_UI_Skeleton )
  40
  41 // ***************************************************************************
  42
  43 uint            USkeleton::getNumBoneComputed() const
  44 {
  45         NL3D_HAUTO_UI_SKELETON;
  46
  47         CSkeletonModel  *object = getObjectPtr();
  48
  49         return object->getNumBoneComputed();
  50 }
  51
  52 // ***************************************************************************
  53
  54 void            USkeleton::setInterpolationDistance(float dist)
  55 {
  56         NL3D_HAUTO_UI_SKELETON;
  57
  58         CSkeletonModel  *object = getObjectPtr();
  59         object->setInterpolationDistance(dist);
  60 }
  61
  62 // ***************************************************************************
  63
  64 float           USkeleton::getInterpolationDistance() const
  65 {
  66         NL3D_HAUTO_UI_SKELETON;
  67
  68         CSkeletonModel  *object = getObjectPtr();
  69         return object->getInterpolationDistance();
  70 }
  71
  72 // ***************************************************************************
  73
  74 void            USkeleton::setShapeDistMax(float distMax)
  75 {
  76         NL3D_HAUTO_UI_SKELETON;
  77         CSkeletonModel  *object = getObjectPtr();
  78
  79         if(object && object->Shape)
  80         {
  81                 object->Shape->setDistMax(distMax);
  82         }
  83 }
  84
  85 // ***************************************************************************
  86
  87 float           USkeleton::getShapeDistMax() const
  88 {
  89         NL3D_HAUTO_UI_SKELETON;
  90         CSkeletonModel  *object = getObjectPtr();
  91
  92         if(object && object->Shape)
  93         {
  94                 return object->Shape->getDistMax();
  95         }
  96         else
  97                 return -1;
  98 }
  99
 100 // ***************************************************************************
 101
 102 bool            USkeleton::bindSkin(UInstance mi)
 103 {
 104         NL3D_HAUTO_UI_SKELETON;
 105
 106         if(mi.empty())
 107         {
 108                 nlerror("USkeleton::bindSkin(): mi is NULL");
 109                 return false;
 110         }
 111         CTransform                      *trans= dynamic_cast<CTransform*>(mi.getObjectPtr());
 112         CMeshBaseInstance       *meshi= dynamic_cast<CMeshBaseInstance*>(trans);
 113         if(meshi==NULL)
 114         {
 115                 nlerror("USkeleton::bindSkin(): mi is not a MeshInstance or MeshMRMInstance");
 116                 return false;
 117         }
 118         CSkeletonModel  *object = getObjectPtr();
 119         return object->bindSkin(meshi);
 120 }
 121
 122 // ***************************************************************************
 123
 124 void            USkeleton::stickObject(UTransform mi, uint boneId)
 125 {
 126         NL3D_HAUTO_UI_SKELETON;
 127         CSkeletonModel  *object = getObjectPtr();
 128
 129         if(mi.empty())
 130                 nlerror("USkeleton::stickObject(): mi is NULL");
 131         CTransform              *trans= dynamic_cast<CTransform*>(mi.getObjectPtr());
 132         object->stickObject(trans, boneId);
 133 }
 134
 135 // ***************************************************************************
 136
 137 void            USkeleton::stickObjectEx(UTransform mi, uint boneId, bool forceCLod)
 138 {
 139         NL3D_HAUTO_UI_SKELETON;
 140         CSkeletonModel  *object = getObjectPtr();
 141
 142         if(mi.empty())
 143                 nlerror("USkeleton::stickObject(): mi is NULL");
 144         CTransform              *trans= dynamic_cast<CTransform*>(mi.getObjectPtr());
 145         object->stickObjectEx(trans, boneId, forceCLod);
 146 }
 147
 148 // ***************************************************************************
 149
 150 void            USkeleton::detachSkeletonSon(UTransform mi)
 151 {
 152         NL3D_HAUTO_UI_SKELETON;
 153         CSkeletonModel  *object = getObjectPtr();
 154
 155         if(mi.empty())
 156                 nlerror("USkeleton::detachSkeletonSon(): mi is NULL");
 157         CTransform              *trans= dynamic_cast<CTransform*>(mi.getObjectPtr());
 158         object->detachSkeletonSon(trans);
 159 }
 160
 161 // ***************************************************************************
 162
 163 uint            USkeleton::getNumBones() const
 164 {
 165         NL3D_HAUTO_UI_SKELETON;
 166         CSkeletonModel  *object = getObjectPtr();
 167         return (uint)object->Bones.size();
 168 }
 169
 170 // ***************************************************************************
 171
 172 UBone           USkeleton::getBone(uint boneId) const
 173 {
 174         NL3D_HAUTO_UI_SKELETON;
 175         CSkeletonModel  *object = getObjectPtr();
 176
 177         if(boneId>=object->Bones.size())
 178                 nlerror("getBone(): bad boneId");
 179         return UBone (&(object->Bones[boneId]));
 180 }
 181
 182 // ***************************************************************************
 183
 184 sint            USkeleton::getBoneIdByName(const std::string &boneName) const
 185 {
 186         NL3D_HAUTO_UI_SKELETON;
 187
 188         CSkeletonModel  *object = getObjectPtr();
 189         return object->getBoneIdByName(boneName);
 190 }
 191
 192 // ***************************************************************************
 193
 194 bool            USkeleton::isBoneComputed(uint boneId) const
 195 {
 196         NL3D_HAUTO_UI_SKELETON;
 197
 198         CSkeletonModel  *object = getObjectPtr();
 199         return object->isBoneComputed(boneId);
 200 }
 201
 202 // ***************************************************************************
 203
 204 bool USkeleton::forceComputeBone(uint boneId)
 205 {
 206         NL3D_HAUTO_UI_SKELETON;
 207
 208         CSkeletonModel  *object = getObjectPtr();
 209         return object->forceComputeBone(boneId);
 210 }
 211
 212 // ***************************************************************************
 213
 214 void            USkeleton::setLodCharacterShape(sint shapeId)
 215 {
 216         NL3D_HAUTO_UI_SKELETON;
 217         CSkeletonModel  *object = getObjectPtr();
 218         object->setLodCharacterShape(shapeId);
 219 }
 220
 221 // ***************************************************************************
 222
 223 sint            USkeleton::getLodCharacterShape() const
 224 {
 225         NL3D_HAUTO_UI_SKELETON;
 226         CSkeletonModel  *object = getObjectPtr();
 227         return object->getLodCharacterShape();
 228 }
 229
 230 // ***************************************************************************
 231
 232 void            USkeleton::enableLOD(bool isEnable)
 233 {
 234         NL3D_HAUTO_UI_SKELETON;
 235         CSkeletonModel  *object = getObjectPtr();
 236         object->enableLOD(isEnable);
 237 }
 238
 239 // ***************************************************************************
 240
 241 void            USkeleton::setLodCharacterAnimId(uint animId)
 242 {
 243         NL3D_HAUTO_UI_SKELETON;
 244         CSkeletonModel  *object = getObjectPtr();
 245         object->setLodCharacterAnimId(animId);
 246 }
 247
 248 // ***************************************************************************
 249
 250 uint            USkeleton::getLodCharacterAnimId() const
 251 {
 252         NL3D_HAUTO_UI_SKELETON;
 253         CSkeletonModel  *object = getObjectPtr();
 254         return object->getLodCharacterAnimId();
 255 }
 256
 257 // ***************************************************************************
 258
 259 void            USkeleton::setLodCharacterAnimTime(TGlobalAnimationTime time)
 260 {
 261         NL3D_HAUTO_UI_SKELETON;
 262         CSkeletonModel  *object = getObjectPtr();
 263         object->setLodCharacterAnimTime(time);
 264 }
 265
 266 // ***************************************************************************
 267
 268 TGlobalAnimationTime    USkeleton::getLodCharacterAnimTime() const
 269 {
 270         NL3D_HAUTO_UI_SKELETON;
 271         CSkeletonModel  *object = getObjectPtr();
 272         return object->getLodCharacterAnimTime();
 273 }
 274
 275 // ***************************************************************************
 276
 277 bool            USkeleton::isDisplayedAsLodCharacter() const
 278 {
 279         NL3D_HAUTO_UI_SKELETON;
 280         CSkeletonModel  *object = getObjectPtr();
 281         return object->isDisplayedAsLodCharacter();
 282 }
 283
 284 // ***************************************************************************
 285
 286 void            USkeleton::setLodCharacterDistance(float dist)
 287 {
 288         NL3D_HAUTO_UI_SKELETON;
 289         CSkeletonModel  *object = getObjectPtr();
 290         object->setLodCharacterDistance(dist);
 291 }
 292
 293 // ***************************************************************************
 294
 295 float           USkeleton::getLodCharacterDistance() const
 296 {
 297         NL3D_HAUTO_UI_SKELETON;
 298         CSkeletonModel  *object = getObjectPtr();
 299         return object->getLodCharacterDistance();
 300 }
 301
 302 // ***************************************************************************
 303
 304 void            USkeleton::setLodCharacterWrapMode(bool wrapMode)
 305 {
 306         NL3D_HAUTO_UI_SKELETON;
 307         CSkeletonModel  *object = getObjectPtr();
 308         object->setLodCharacterWrapMode(wrapMode);
 309 }
 310
 311 // ***************************************************************************
 312
 313 bool            USkeleton::getLodCharacterWrapMode() const
 314 {
 315         NL3D_HAUTO_UI_SKELETON;
 316         CSkeletonModel  *object = getObjectPtr();
 317         return object->getLodCharacterWrapMode();
 318 }
 319
 320 // ***************************************************************************
 321
 322 void            USkeleton::changeMRMDistanceSetup(float distanceFinest, float distanceMiddle, float distanceCoarsest)
 323 {
 324         NL3D_HAUTO_UI_SKELETON;
 325         CSkeletonModel  *object = getObjectPtr();
 326         object->changeMRMDistanceSetup(distanceFinest, distanceMiddle, distanceCoarsest);
 327 }
 328
 329 // ***************************************************************************
 330
 331 bool            USkeleton::computeRenderedBBox(NLMISC::CAABBox &bbox, bool computeInWorld)
 332 {
 333         NL3D_HAUTO_UI_SKELETON;
 334         CSkeletonModel  *object = getObjectPtr();
 335         return object->computeRenderedBBox(bbox, computeInWorld);
 336 }
 337
 338 // ***************************************************************************
 339 bool            USkeleton::computeRenderedBBoxWithBoneSphere(NLMISC::CAABBox &bbox, bool computeInWorld)
 340 {
 341         NL3D_HAUTO_UI_SKELETON;
 342         CSkeletonModel  *object = getObjectPtr();
 343         return object->computeRenderedBBoxWithBoneSphere(bbox, computeInWorld);
 344 }
 345
 346 // ***************************************************************************
 347
 348 bool            USkeleton::computeCurrentBBox(NLMISC::CAABBox &bbox, UPlayList *playList, double playTime, bool forceCompute /* = false */, bool computeInWorld)
 349 {
 350         NL3D_HAUTO_UI_SKELETON;
 351         CSkeletonModel  *object = getObjectPtr();
 352
 353         if(playList!=NULL)
 354         {
 355                 CPlayListUser   *plUser= static_cast<CPlayListUser*>(playList);
 356                 plUser->evalPlayList(playTime);
 357         }
 358
 359         return object->computeCurrentBBox(bbox, forceCompute, computeInWorld);
 360 }
 361
 362 // ***************************************************************************
 363
 364 void            USkeleton::computeLodTexture()
 365 {
 366         NL3D_HAUTO_UI_SKELETON;
 367
 368         CSkeletonModel  *object = getObjectPtr();
 369         object->computeLodTexture();
 370 }
 371
 372 // ***************************************************************************
 373
 374 void            USkeleton::setBoneAnimCtrl(uint boneId, IAnimCtrl *ctrl)
 375 {
 376         NL3D_HAUTO_UI_SKELETON;
 377
 378         CSkeletonModel  *object = getObjectPtr();
 379         object->setBoneAnimCtrl(boneId, ctrl);
 380 }
 381
 382 // ***************************************************************************
 383
 384 IAnimCtrl       *USkeleton::getBoneAnimCtrl(uint boneId) const
 385 {
 386         NL3D_HAUTO_UI_SKELETON;
 387
 388         CSkeletonModel  *object = getObjectPtr();
 389         return object->getBoneAnimCtrl(boneId);
 390 }
 391
 392 // ***************************************************************************
 393 void                                    USkeleton::setSSSWOPos(const NLMISC::CVector &pos)
 394 {
 395         NL3D_HAUTO_UI_SKELETON;
 396         CSkeletonModel  *object = getObjectPtr();
 397         object->setSSSWOPos(pos);
 398 }
 399
 400 // ***************************************************************************
 401 const NLMISC::CVector   &USkeleton::getSSSWOPos() const
 402 {
 403         NL3D_HAUTO_UI_SKELETON;
 404         CSkeletonModel  *object = getObjectPtr();
 405         return object->getSSSWOPos();
 406 }
 407
 408 // ***************************************************************************
 409 void                                    USkeleton::setSSSWODir(const NLMISC::CVector &dir)
 410 {
 411         NL3D_HAUTO_UI_SKELETON;
 412         CSkeletonModel  *object = getObjectPtr();
 413         object->setSSSWODir(dir);
 414 }
 415
 416 // ***************************************************************************
 417 const NLMISC::CVector   &USkeleton::getSSSWODir() const
 418 {
 419         NL3D_HAUTO_UI_SKELETON;
 420         CSkeletonModel  *object = getObjectPtr();
 421         return object->getSSSWODir();
 422 }
 423
 424 // ***************************************************************************
 425 const std::string               &USkeleton::getShapeName() const
 426 {
 427         NL3D_HAUTO_UI_SKELETON;
 428
 429         static std::string emptyStr;
 430
 431         CSkeletonModel  *object = getObjectPtr();
 432         if(!object)
 433                 return emptyStr;
 434
 435         // get the shape bank
 436         CScene *scene= object->getOwnerScene();
 437         CShapeBank      *sb= scene->getShapeBank();
 438         if(!sb)
 439                 return emptyStr;
 440
 441         // get the shape name
 442         const std::string *str= sb->getShapeNameFromShapePtr(object->Shape);
 443         if(str)
 444                 return *str;
 445         else
 446                 return emptyStr;
 447
 448 }
 449
 450 // ***************************************************************************
 451 void USkeleton::getStickedObjects(std::vector<UTransform> &sticks)
 452 {
 453         NL3D_HAUTO_UI_SKELETON;
 454
 455         sticks.clear();
 456
 457         CSkeletonModel  *sm= getObjectPtr();
 458         if(!sm)
 459                 return;
 460
 461         const std::set<CTransform*>     &stickSet= sm->getStickedObjects();
 462         std::set<CTransform*>::const_iterator   it= stickSet.begin();
 463         sticks.reserve(stickSet.size());
 464         for(;it!=stickSet.end();it++)
 465         {
 466                 sticks.push_back(*it);
 467         }
 468 }
 469
 470 // ***************************************************************************
 471 void USkeleton::cast(UTransform object)
 472 {
 473         attach(dynamic_cast<CSkeletonModel*>(object.getObjectPtr()));
 474 }
 475
 476 // ***************************************************************************
 477 void                    USkeleton::setLodEmit(NLMISC::CRGBA emit)
 478 {
 479         getObjectPtr()->setLodEmit(emit);
 480 }
 481
 482 // ***************************************************************************
 483 NLMISC::CRGBA   USkeleton::getLodEmit() const
 484 {
 485         return getObjectPtr()->getLodEmit();
 486 }
 487
 488
 489 } // NL3D