nel/src/3d/mesh_base_instance.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/mesh_base_instance.h"
  20 #include "nel/3d/mesh_base.h"
  21 #include "nel/3d/scene.h"
  22 #include "nel/3d/animation.h"
  23 #include "nel/misc/debug.h"
  24 #include "nel/3d/anim_detail_trav.h"
  25 #include "nel/3d/texture_file.h"
  26 #include "nel/3d/async_texture_manager.h"
  27
  28 #include <limits>
  29
  30 using namespace NLMISC;
  31
  32 #ifdef DEBUG_NEW
  33 #define new DEBUG_NEW
  34 #endif
  35
  36 namespace NL3D
  37 {
  38
  39
  40 // ***************************************************************************
  41 CMeshBaseInstance::CMeshBaseInstance()
  42 {
  43         IAnimatable::resize(AnimValueLast);
  44         _AsyncTextureToLoadRefCount= 0;
  45         _AsyncTextureMode= false;
  46         _AsyncTextureReady= true;
  47         _AsyncTextureDirty= false;
  48         _AsyncTextureDistance= 0;
  49         _VPWindTreeFixed = false;
  50
  51         // I am a CMeshBaseInstance!!
  52         CTransform::setIsMeshBaseInstance(true);
  53 }
  54
  55 // ***************************************************************************
  56 CMeshBaseInstance::~CMeshBaseInstance()
  57 {
  58         // If AsyncTextureMode, must disable. This ensure that async loading stop, and that no ref still exist
  59         // in the AsyncTextureManager
  60         if(_AsyncTextureMode)
  61                 enableAsyncTextureMode(false);
  62 }
  63
  64
  65 // ***************************************************************************
  66 void            CMeshBaseInstance::registerBasic()
  67 {
  68         CScene::registerModel(MeshBaseInstanceId, TransformShapeId, CMeshBaseInstance::creator);
  69 }
  70
  71
  72 // ***************************************************************************
  73 void            CMeshBaseInstance::registerToChannelMixer(CChannelMixer *chanMixer, const std::string &prefix)
  74 {
  75         uint32 i;
  76         CTransformShape::registerToChannelMixer(chanMixer, prefix);
  77
  78         // Add any materials.
  79         for (i = 0; i < _AnimatedMaterials.size(); i++)
  80         {
  81                 // append material  matname.*
  82                 _AnimatedMaterials[i].registerToChannelMixer(chanMixer, prefix + _AnimatedMaterials[i].getMaterialName() + ".");
  83         }
  84
  85         // Add any morph
  86         for (i = 0; i < _AnimatedMorphFactor.size(); i++)
  87         {
  88                 _AnimatedMorphFactor[i].registerToChannelMixer(chanMixer, prefix + _AnimatedMorphFactor[i].getName());
  89         }
  90 }
  91
  92
  93 // ***************************************************************************
  94 ITrack*         CMeshBaseInstance::getDefaultTrack (uint valueId)
  95 {
  96         // Pointer on the CMeshBase
  97         CMeshBase* pMesh=(CMeshBase*)(IShape*)Shape;
  98
  99         // Switch the value
 100         switch (valueId)
 101         {
 102         case CTransform::PosValue:
 103                 return pMesh->getDefaultPos();
 104         case CTransform::RotEulerValue:
 105                 return pMesh->getDefaultRotEuler();
 106         case CTransform::RotQuatValue:
 107                 return pMesh->getDefaultRotQuat();
 108         case CTransform::ScaleValue:
 109                 return pMesh->getDefaultScale();
 110         case CTransform::PivotValue:
 111                 return pMesh->getDefaultPivot();
 112         default:
 113                 // Problem, new values ?
 114                 nlstop;
 115         };
 116         return NULL;
 117 }
 118
 119
 120 // ***************************************************************************
 121 uint32 CMeshBaseInstance::getNbLightMap()
 122 {
 123         CMeshBase* pMesh=(CMeshBase*)(IShape*)Shape;
 124         return (uint32)pMesh->_LightInfos.size();
 125 }
 126
 127 // ***************************************************************************
 128 void CMeshBaseInstance::getLightMapName( uint32 nLightMapNb, std::string &LightMapName )
 129 {
 130         CMeshBase* pMesh=(CMeshBase*)(IShape*)Shape;
 131         if( nLightMapNb >= pMesh->_LightInfos.size() )
 132                 return;
 133         LightMapName = pMesh->_LightInfos[nLightMapNb].AnimatedLight;
 134 }
 135
 136 // ***************************************************************************
 137 uint32 CMeshBaseInstance::getNbBlendShape()
 138 {
 139         return (uint32)_AnimatedMorphFactor.size();
 140 }
 141
 142 // ***************************************************************************
 143 void CMeshBaseInstance::getBlendShapeName (uint32 nBlendShapeNb, std::string &BlendShapeName )
 144 {
 145         if (nBlendShapeNb >= _AnimatedMorphFactor.size())
 146                 return;
 147         BlendShapeName = _AnimatedMorphFactor[nBlendShapeNb].getName();
 148 }
 149
 150 // ***************************************************************************
 151 void CMeshBaseInstance::setBlendShapeFactor (const std::string &BlendShapeName, float rFactor)
 152 {
 153         for (uint32 i = 0; i < _AnimatedMorphFactor.size(); ++i)
 154                 if (BlendShapeName == _AnimatedMorphFactor[i].getName())
 155                 {
 156                         _AnimatedMorphFactor[i].setFactor (rFactor);
 157                 }
 158 }
 159
 160 // ***************************************************************************
 161 void CMeshBaseInstance::traverseHrc()
 162 {
 163         CMeshBase                       *mb = NLMISC::safe_cast<CMeshBase *>((IShape *) Shape);
 164
 165         // if the base instance uses automatic animations, we must also setup the date of the channel mixer controlling this object
 166         if (mb->getAutoAnim())
 167         {
 168                 // Unfreeze HRC for those models
 169                 CTransform *node = this;
 170                 while (node)
 171                 {
 172                         node->unfreezeHRC();
 173                         node = node->hrcGetParent();
 174                 }
 175
 176                 // setup the channel mixer date
 177                 CChannelMixer *chanMix = getChannelMixer();
 178                 if (chanMix)
 179                 {
 180                         const CAnimation *anim = chanMix->getSlotAnimation(0);
 181                         /** We perform wrapping ourselves.
 182                           * We avoid using a playlist, to not create one more obj.
 183                           */
 184                         if (anim)
 185                         {
 186                                 // Animation offset are setuped before clipping, they will be used for detail too.
 187                                 float animLength = anim->getEndTime() - anim->getBeginTime();
 188                                 if (animLength > 0)
 189                                 {
 190                                         float currTime = (TAnimationTime) getOwnerScene()->getCurrentTime();
 191                                         float startTime = (uint) (currTime / animLength) * animLength;
 192                                         // Set the channel mixer date using the global date of the scene
 193                                         chanMix->setSlotTime(0, anim->getBeginTime() + currTime - startTime);
 194                                 }
 195                                 else
 196                                 {
 197                                         chanMix->setSlotTime(0, anim->getBeginTime());
 198                                 }
 199
 200                                 /** Eval non detail animation
 201                                   */
 202                                 chanMix->eval(false);
 203                         }
 204                 }
 205         }
 206
 207         CTransformShape::traverseHrc();
 208 }
 209
 210 // ***************************************************************************
 211 void CMeshBaseInstance::traverseAnimDetail()
 212 {
 213         CMeshBase                       *mb = NLMISC::safe_cast<CMeshBase *>((IShape *) Shape);
 214
 215         CTransformShape::traverseAnimDetail();
 216
 217
 218         // update animated materials.
 219         // test if animated materials must be updated.
 220         if(IAnimatable::isTouched(CMeshBaseInstance::OwnerBit))
 221         {
 222                 // must test / update all AnimatedMaterials.
 223                 for(uint i=0;i<_AnimatedMaterials.size();i++)
 224                 {
 225                         // This test and update the pointed material.
 226                         _AnimatedMaterials[i].update();
 227                 }
 228
 229                 IAnimatable::clearFlag(CMeshBaseInstance::OwnerBit);
 230         }
 231
 232         // Lightmap automatic animation
 233
 234         // Animated lightmap must have the same size than shape info lightmap.
 235         const uint count0 = (uint)_AnimatedLightmap.size();
 236         const uint count1 = (uint)mb->_LightInfos.size ();
 237         nlassert (count0 == count1);
 238         if (count0 == count1)
 239         {
 240                 for ( uint i = 0; i < count0; ++i )
 241                 {
 242                         CMeshBase::CLightMapInfoList &groupInfo = mb->_LightInfos[i];
 243                         std::list<CMeshBase::CLightMapInfoList::CMatStage>::iterator ite = groupInfo.StageList.begin ();
 244                         while (ite != groupInfo.StageList.end ())
 245                         {
 246                                 sint animatedLightmap = _AnimatedLightmap[i];
 247                                 if (animatedLightmap != -1)
 248                                 {
 249                                         CRGBA factor = getOwnerScene ()->getAnimatedLightFactor (animatedLightmap, groupInfo.LightGroup);
 250                                         Materials[ite->MatId].setLightMapFactor ( ite->StageId, factor );
 251                                 }
 252                                 else
 253                                 {
 254                                         CRGBA factor = getOwnerScene ()->getLightmapGroupColor (groupInfo.LightGroup);
 255                                         Materials[ite->MatId].setLightMapFactor ( ite->StageId, factor );
 256                                 }
 257                                 ite++;
 258                         }
 259                 }
 260         }
 261 }
 262
 263
 264 // ***************************************************************************
 265 void CMeshBaseInstance::selectTextureSet(uint id)
 266 {
 267         nlassert(Shape);
 268         CMeshBase *mb = NLMISC::safe_cast<CMeshBase *>((IShape *) Shape);
 269         const uint numMat = mb->getNbMaterial();
 270         nlassert(numMat == Materials.size());
 271         // see which material are selectable
 272         for(uint k = 0; k < numMat; ++k)
 273         {
 274                 CMaterial &mat = mb->getMaterial(k);
 275                 for(uint l = 0; l < IDRV_MAT_MAXTEXTURES; ++l)
 276                 {
 277                         if (mat.getTexture(uint8(l)) && mat.getTexture(uint8(l))->isSelectable())
 278                         {
 279                                 // use a smartPtr so the textFile will be released if just used to set the name for AsyncTextures.
 280                                 CSmartPtr<ITexture>             texNSV= mat.getTexture(uint8(l))->buildNonSelectableVersion(id);
 281
 282                                 // std case: just replace the texture.
 283                                 if(!_AsyncTextureMode)
 284                                 {
 285                                         Materials[k].setTexture(uint8(l), texNSV);
 286                                 }
 287                                 // Async case
 288                                 else
 289                                 {
 290                                         // If texture file, must copy the texture name
 291                                         if(AsyncTextures[k].IsTextureFile[l])
 292                                         {
 293                                                 CTextureFile    *textFile= safe_cast<CTextureFile*>((ITexture*)texNSV);
 294                                                 AsyncTextures[k].TextureNames[l]= textFile->getFileName();
 295                                         }
 296                                         // else replace the texture.
 297                                         else
 298                                                 Materials[k].setTexture(uint8(l), texNSV);
 299                                 }
 300                         }
 301                 }
 302         }
 303
 304         // Flag the instance as AsyncTextureDirty if in this mode
 305         if(_AsyncTextureMode)
 306         {
 307                 setAsyncTextureDirty(true);
 308         }
 309 }
 310
 311
 312 // ***************************************************************************
 313 void CMeshBaseInstance::initAnimatedLightIndex (const CScene &scene)
 314 {
 315         /* Scan lightmaps used by the shape, and for each, bind the transform shape to an
 316          * animated lightmap index from the scene. This index will be used at runtime to
 317          * get quickly a lightmap factor. This index is not set in the CShape because
 318          * the CShape can be used with several CScene.
 319          */
 320
 321         // For each lightmap in the shape
 322         CMeshBase *pMB = static_cast<CMeshBase*> (static_cast<IShape*> (Shape));
 323         const uint count = (uint)pMB->_LightInfos.size ();
 324         uint i;
 325
 326         // Resize the index array
 327         _AnimatedLightmap.resize (count);
 328
 329         for (i=0; i<count; i++)
 330         {
 331                 // The light info
 332                 CMeshBase::CLightMapInfoList &lightInfo = pMB->_LightInfos[i];
 333
 334                 // Get the lightmap info
 335                 _AnimatedLightmap[i] = scene.getAnimatedLightNameToIndex (lightInfo.AnimatedLight);
 336         }
 337
 338         // Must be traversed in AnimDetail, even if no channel mixer registered
 339         CTransform::setIsForceAnimDetail (count != 0);
 340 }
 341
 342
 343 // ***************************************************************************
 344 uint CMeshBaseInstance::getNumMaterial () const
 345 {
 346         return (uint)Materials.size ();
 347 }
 348
 349
 350 // ***************************************************************************
 351 const CMaterial *CMeshBaseInstance::getMaterial (uint materialId) const
 352 {
 353         return &(Materials[materialId]);
 354 }
 355
 356
 357 // ***************************************************************************
 358 CMaterial       *CMeshBaseInstance::getMaterial (uint materialId)
 359 {
 360         return &(Materials[materialId]);
 361 }
 362
 363
 364 // ***************************************************************************
 365 bool            CMeshBaseInstance::fastIntersect(const NLMISC::CVector &p0, const NLMISC::CVector &dir, float &dist2D, float &distZ, bool computeDist2D)
 366 {
 367         if(!Shape || !supportFastIntersect())
 368                 return false;
 369
 370         // Use the system geometry to test the intersection
 371         CMeshBase *pMB = static_cast<CMeshBase*> (static_cast<IShape*> (Shape));
 372         return pMB->getSystemGeometry().fastIntersect(getWorldMatrix(), p0, dir, dist2D, distZ, computeDist2D);
 373 }
 374
 375
 376 // ***************************************************************************
 377 // ***************************************************************************
 378 // Async texture loading
 379 // ***************************************************************************
 380 // ***************************************************************************
 381
 382
 383 // ***************************************************************************
 384 void                    CMeshBaseInstance::enableAsyncTextureMode(bool enable)
 385 {
 386         // if same, no-op.
 387         if(_AsyncTextureMode==enable)
 388                 return;
 389         _AsyncTextureMode= enable;
 390
 391         // if comes to async texture mode, must prepare AsyncTexturing
 392         if(_AsyncTextureMode)
 393         {
 394                 _AsyncTextureReady= true;
 395
 396                 // For all TextureFiles in material
 397                 for(uint i=0;i<Materials.size();i++)
 398                 {
 399                         for(uint stage=0;stage<IDRV_MAT_MAXTEXTURES;stage++)
 400                         {
 401                                 // test if really a CTextureFile
 402                                 CTextureFile    *text= dynamic_cast<CTextureFile*>(Materials[i].getTexture(uint8(stage)));
 403                                 if(text)
 404                                 {
 405                                         // Must setup the AsyncTextures
 406                                         AsyncTextures[i].IsTextureFile[stage]= true;
 407                                         AsyncTextures[i].TextureNames[stage]= text->getFileName();
 408                                         AsyncTextures[i].TextIds[stage]= std::numeric_limits<uint>::max();
 409                                         // Now, must copy the textureFile, to Avoid writing in CMeshBase TextureFile descriptor !!!
 410                                         CTextureFile *tf = new CTextureFile(*text);
 411                                         // setup a dummy texture => Instance won't block rendering because texture not yet ready
 412                                         tf->setFileName("blank.tga");
 413                                         Materials[i].setTexture(uint8(stage), tf);
 414                                 }
 415                                 else
 416                                 {
 417                                         AsyncTextures[i].IsTextureFile[stage]= false;
 418                                 }
 419                         }
 420                 }
 421
 422                 // For convenience, flag the instance as Dirty.
 423                 setAsyncTextureDirty(true);
 424         }
 425         // else, AsyncTextureMode disabled
 426         else
 427         {
 428                 // first, must stop and release all textures in the async manager.
 429                 releaseCurrentAsyncTextures();
 430                 nlassert(_AsyncTextureToLoadRefCount==0);
 431                 // clear the array => ensure good work if enableAsyncTextureMode(true) is made later
 432                 contReset(_CurrentAsyncTextures);
 433
 434                 // For all TextureFiles in material, copy User setup from AsyncTextures, to real fileName
 435                 for(uint i=0;i<Materials.size();i++)
 436                 {
 437                         for(uint stage=0;stage<IDRV_MAT_MAXTEXTURES;stage++)
 438                         {
 439                                 // if an async texture file
 440                                 if(AsyncTextures[i].IsTextureFile[stage])
 441                                 {
 442                                         // copy the texture name into the texture file.
 443                                         CTextureFile    *text= safe_cast<CTextureFile*>(Materials[i].getTexture(uint8(stage)));
 444                                         text->setFileName(AsyncTextures[i].TextureNames[stage]);
 445                                         // clear string space
 446                                         AsyncTextures[i].TextureNames[stage].clear();
 447                                 }
 448                         }
 449                 }
 450         }
 451 }
 452
 453
 454 // ***************************************************************************
 455 void                    CMeshBaseInstance::startAsyncTextureLoading(const NLMISC::CVector &position)
 456 {
 457         if(!getAsyncTextureMode())
 458                 return;
 459
 460         // If the async texutre manager is not setuped in the scene, abort.
 461         CAsyncTextureManager    *asyncTextMgr= getOwnerScene()->getAsyncTextureManager();
 462         if(!asyncTextMgr)
 463                 return;
 464
 465         uint    i;
 466
 467
 468         /* for all new texture names to load, add them to the manager
 469                 NB: done first before release because of RefCount Management (in case of same texture name).
 470         */
 471         for(i=0;i<AsyncTextures.size();i++)
 472         {
 473                 for(uint stage=0;stage<IDRV_MAT_MAXTEXTURES;stage++)
 474                 {
 475                         if(AsyncTextures[i].IsTextureFile[stage])
 476                         {
 477                                 uint    id;
 478                                 id= asyncTextMgr->addTextureRef(AsyncTextures[i].TextureNames[stage], this, position);
 479                                 AsyncTextures[i].TextIds[stage]= id;
 480                         }
 481                 }
 482         }
 483
 484         /* For all old textures (0 for the first time...), release them.
 485         */
 486         releaseCurrentAsyncTextures();
 487
 488         // OK! bkup the setup
 489         _CurrentAsyncTextures= AsyncTextures;
 490
 491         // texture async is not ready.
 492         _AsyncTextureReady= false;
 493 }
 494
 495 // ***************************************************************************
 496 void                    CMeshBaseInstance::releaseCurrentAsyncTextures()
 497 {
 498         // If the async texutre manager is not setuped in the scene, abort.
 499         CAsyncTextureManager    *asyncTextMgr= getOwnerScene()->getAsyncTextureManager();
 500         if(!asyncTextMgr)
 501                 return;
 502
 503         // release all texture in the manager
 504         for(uint i=0;i<_CurrentAsyncTextures.size();i++)
 505         {
 506                 for(uint stage=0;stage<IDRV_MAT_MAXTEXTURES;stage++)
 507                 {
 508                         if(_CurrentAsyncTextures[i].IsTextureFile[stage])
 509                         {
 510                                 asyncTextMgr->releaseTexture(_CurrentAsyncTextures[i].TextIds[stage], this);
 511                         }
 512                 }
 513         }
 514 }
 515
 516 // ***************************************************************************
 517 bool                    CMeshBaseInstance::isAsyncTextureReady()
 518 {
 519         // if ok, just quit
 520         if(_AsyncTextureReady)
 521                 return true;
 522
 523         // test if async loading ended
 524         if(_AsyncTextureToLoadRefCount==0)
 525         {
 526                 // must copy all fileNames into the actual Texture Files. Those are the valid ones now!
 527                 for(uint i=0;i<_CurrentAsyncTextures.size();i++)
 528                 {
 529                         for(uint stage=0;stage<IDRV_MAT_MAXTEXTURES;stage++)
 530                         {
 531                                 if(_CurrentAsyncTextures[i].IsTextureFile[stage])
 532                                 {
 533                                         // copy the texture name into the texture file.
 534                                         CTextureFile    *text= safe_cast<CTextureFile*>(Materials[i].getTexture(uint8(stage)));
 535                                         // Since the texture is really uploaded in the driver, the true driver Texture Id will
 536                                         // be bound to this texture.
 537                                         text->setFileName(_CurrentAsyncTextures[i].TextureNames[stage]);
 538                                         /* Since driver setup will only occurs when object become visible, it is a good idea to release
 539                                            Old driver info, because it may points to old driver texture data (eg: old shared textureFile).
 540                                            thus doing so release VRAM Texture Memory
 541                                         */
 542                                         text->releaseDriverSetup();
 543                                 }
 544                         }
 545                 }
 546
 547                 // Ok, we are now ready.
 548                 _AsyncTextureReady= true;
 549                 return true;
 550         }
 551         else
 552                 return false;
 553 }
 554
 555
 556 // ***************************************************************************
 557 sint                    CMeshBaseInstance::getAsyncTextureId(uint matId, uint stage) const
 558 {
 559         if(matId>=_CurrentAsyncTextures.size())
 560                 return -1;
 561         if(!_CurrentAsyncTextures[matId].isTextureFile(stage))
 562                 return -1;
 563         return _CurrentAsyncTextures[matId].TextIds[stage];
 564 }
 565
 566
 567
 568 } // NL3D