nel/src/3d/instance_group_user.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/misc/debug.h"
  20 #include "nel/3d/instance_group_user.h"
  21 #include "nel/3d/scene_user.h"
  22 #include "nel/3d/mesh_multi_lod_instance.h"
  23 #include "nel/3d/text_context_user.h"
  24 #include "nel/3d/particle_system_model.h"
  25 #include "nel/misc/path.h"
  26 #include "nel/misc/file.h"
  27 #include "nel/3d/u_instance.h"
  28
  29 using namespace NLMISC;
  30 using namespace std;
  31
  32 #ifdef DEBUG_NEW
  33 #define new DEBUG_NEW
  34 #endif
  35
  36 namespace NL3D
  37 {
  38
  39 // ***************************************************************************
  40
  41 UInstanceGroup  *UInstanceGroup::createInstanceGroup (const std::string &instanceGroup)
  42 {
  43         // Create the instance group
  44         CInstanceGroupUser *user=new CInstanceGroupUser;
  45
  46         // Init the class
  47         if (!user->init (instanceGroup))
  48         {
  49                 // Prb, erase it
  50                 delete user;
  51
  52                 // Return error code
  53                 return NULL;
  54         }
  55
  56         // return the good value
  57         return user;
  58 }
  59
  60 // ***************************************************************************
  61
  62 void UInstanceGroup::createInstanceGroupAsync (const std::string &instanceGroup, UInstanceGroup **pIG)
  63 {
  64         CAsyncFileManager3D::getInstance().loadIGUser (instanceGroup, pIG);
  65 }
  66
  67 // ***************************************************************************
  68
  69 void UInstanceGroup::stopCreateInstanceGroupAsync (UInstanceGroup **ppIG)
  70 {
  71         // Theorically should stop the async file manager but the async file manager can only be stopped
  72         // between tasks (a file reading) so that is no sense to do anything here
  73         while (*ppIG == NULL)
  74         {
  75                 nlSleep (2);
  76         }
  77         if (*ppIG != (UInstanceGroup*)-1)
  78         {
  79                 delete *ppIG;
  80         }
  81 }
  82
  83 // ***************************************************************************
  84 CInstanceGroupUser::CInstanceGroupUser()
  85 {
  86         /* ***********************************************
  87          *      WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
  88          *      It can be loaded/called through CAsyncFileManager for instance
  89          * ***********************************************/
  90
  91         _AddToSceneState = StateNotAdded;
  92
  93         // set user info for possible get
  94         _InstanceGroup.setUserInterface(this);
  95 }
  96
  97 // ***************************************************************************
  98 CInstanceGroupUser::~CInstanceGroupUser()
  99 {
 100         /* ***********************************************
 101          *      WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
 102          *      It can be loaded/called through CAsyncFileManager for instance
 103          * ***********************************************/
 104
 105         // ensure all instances proxys are deleted
 106         removeInstancesUser();
 107 }
 108
 109 // ***************************************************************************
 110 bool CInstanceGroupUser::init (const std::string &instanceGroup, bool async)
 111 {
 112         // Create a file
 113         CIFile file;
 114         if(async)
 115         {
 116                 file.setAsyncLoading(true);
 117                 file.setCacheFileOnOpen(true);
 118         }
 119         std::string path = CPath::lookup (instanceGroup, false);
 120         if (!path.empty() && file.open (path))
 121         {
 122                 // Serialize this class
 123                 try
 124                 {
 125                         // Read the class
 126                         _InstanceGroup.serial (file);
 127                 }
 128                 catch (const EStream& e)
 129                 {
 130                         // Avoid visual warning
 131                         EStream ee=e;
 132
 133                         // Serial problem
 134                         return false;
 135                 }
 136         }
 137         else
 138         {
 139                 // Failed.
 140                 return false;
 141         }
 142
 143         // Ok
 144         return true;
 145 }
 146
 147 // ***************************************************************************
 148 void CInstanceGroupUser::setTransformNameCallback (ITransformName *pTN)
 149 {
 150         _InstanceGroup.setTransformNameCallback (pTN);
 151 }
 152
 153
 154 // ***************************************************************************
 155 void CInstanceGroupUser::setAddRemoveInstanceCallback(IAddRemoveInstance *callback)
 156 {
 157         _InstanceGroup.setAddRemoveInstanceCallback(callback);
 158 }
 159
 160
 161 // ***************************************************************************
 162 void CInstanceGroupUser::setIGAddBeginCallback(IIGAddBegin *callback)
 163 {
 164         _InstanceGroup.setIGAddBeginCallback(callback);
 165 }
 166
 167
 168
 169 // ***************************************************************************
 170 void CInstanceGroupUser::addToScene (class UScene& scene, UDriver *driver, uint selectedTexture)
 171 {
 172         // Get driver pointer
 173         IDriver *cDriver= driver ? NLMISC::safe_cast<CDriverUser*>(driver)->getDriver() : NULL;
 174
 175         // Add to the scene
 176         addToScene (((CSceneUser*)&scene)->getScene(), cDriver, selectedTexture);
 177 }
 178
 179 // ***************************************************************************
 180 void CInstanceGroupUser::getInstanceMatrix(uint instanceNb,NLMISC::CMatrix &dest) const
 181 {
 182         _InstanceGroup.getInstanceMatrix(instanceNb, dest);
 183 }
 184
 185
 186 // ***************************************************************************
 187 void CInstanceGroupUser::addToScene (class CScene& scene, IDriver *driver, uint selectedTexture)
 188 {
 189         if (!_InstanceGroup.addToScene (scene, driver, selectedTexture))
 190                 return;
 191         // Fill in the vector and the map accelerating search of instance by names
 192         for( uint32 i = 0; i < _InstanceGroup._Instances.size(); ++i)
 193         {
 194                 string stmp;
 195                 if (_InstanceGroup._Instances[i] != NULL)
 196                 {
 197                         // insert in map (may fail if double name)
 198                         stmp = _InstanceGroup.getInstanceName (i);
 199                         _InstanceMap.insert (map<string,CTransformShape*>::value_type(stmp, _InstanceGroup._Instances[i]));
 200                 }
 201         }
 202 }
 203
 204 // ***************************************************************************
 205 void CInstanceGroupUser::addToSceneAsync (class UScene& scene, UDriver *driver, uint selectedTexture)
 206 {
 207         IDriver *cDriver= driver ? NLMISC::safe_cast<CDriverUser*>(driver)->getDriver() : NULL;
 208         // Add to the scene
 209         _InstanceGroup.addToSceneAsync (((CSceneUser*)&scene)->getScene(), cDriver, selectedTexture);
 210         _AddToSceneState = StateAdding;
 211         _AddToSceneTempScene = &scene;
 212         _AddToSceneTempDriver = driver;
 213 }
 214
 215 // ***************************************************************************
 216 void CInstanceGroupUser::stopAddToSceneAsync ()
 217 {
 218         _InstanceGroup.stopAddToSceneAsync ();
 219 }
 220
 221 // ***************************************************************************
 222 UInstanceGroup::TState CInstanceGroupUser::getAddToSceneState ()
 223 {
 224         UInstanceGroup::TState newState = (UInstanceGroup::TState)_InstanceGroup.getAddToSceneState ();
 225         if ((_AddToSceneState == StateAdding) && (newState == StateAdded))
 226         {
 227                 // Fill in the vector and the map accelerating search of instance by names
 228                 for( uint32 i = 0; i < _InstanceGroup._Instances.size(); ++i)
 229                 {
 230                         string stmp;
 231                         if (_InstanceGroup._Instances[i] != NULL)
 232                         {
 233                                 // create but don't want to delete from scene, since added/removed with _InstanceGroup
 234                                 // insert in map (may fail if double name)
 235                                 stmp = _InstanceGroup.getInstanceName (i);
 236                                 _InstanceMap.insert (map<string,CTransformShape*>::value_type(stmp, _InstanceGroup._Instances[i]));
 237                         }
 238                 }
 239                 _AddToSceneState = StateAdded;
 240         }
 241         return newState;
 242 }
 243
 244 // ***************************************************************************
 245 void CInstanceGroupUser::removeFromScene (class UScene& scene)
 246 {
 247         _InstanceGroup.removeFromScene (((CSceneUser*)&scene)->getScene());
 248         // Remove all instance user object in the array/map
 249         removeInstancesUser();
 250 }
 251
 252 // ***************************************************************************
 253 uint CInstanceGroupUser::getNumInstance () const
 254 {
 255         return _InstanceGroup.getNumInstance ();
 256 }
 257
 258 // ***************************************************************************
 259
 260 const std::string& CInstanceGroupUser::getShapeName (uint instanceNb) const
 261 {
 262         // Check args
 263         if (instanceNb>=_InstanceGroup.getNumInstance ())
 264                 nlerror("getShapeName*(): bad instance Id");
 265
 266         return _InstanceGroup.getShapeName (instanceNb);
 267 }
 268
 269 // ***************************************************************************
 270 const std::string& CInstanceGroupUser::getInstanceName (uint instanceNb) const
 271 {
 272         // Check args
 273         if (instanceNb>=_InstanceGroup.getNumInstance ())
 274                 nlerror("getInstanceName*(): bad instance Id");
 275
 276         return _InstanceGroup.getInstanceName (instanceNb);
 277 }
 278
 279 // ***************************************************************************
 280 const NLMISC::CVector& CInstanceGroupUser::getInstancePos (uint instanceNb) const
 281 {
 282         // Check args
 283         if (instanceNb>=_InstanceGroup.getNumInstance ())
 284                 nlerror("getInstancePos*(): bad instance Id");
 285
 286         return _InstanceGroup.getInstancePos (instanceNb);
 287 }
 288
 289 // ***************************************************************************
 290 const NLMISC::CQuat& CInstanceGroupUser::getInstanceRot (uint instanceNb) const
 291 {
 292         // Check args
 293         if (instanceNb>=_InstanceGroup.getNumInstance ())
 294                 nlerror("getInstanceRot*(): bad instance Id");
 295
 296         return _InstanceGroup.getInstanceRot (instanceNb);
 297 }
 298
 299 // ***************************************************************************
 300 const NLMISC::CVector& CInstanceGroupUser::getInstanceScale (uint instanceNb) const
 301 {
 302         // Check args
 303         if (instanceNb>=_InstanceGroup.getNumInstance ())
 304                 nlerror("getInstanceScale*(): bad instance Id");
 305
 306         return _InstanceGroup.getInstanceScale (instanceNb);
 307 }
 308
 309 // ***************************************************************************
 310
 311 UInstance CInstanceGroupUser::getByName (const std::string &name) const
 312 {
 313         map<string,CTransformShape*>::const_iterator it = _InstanceMap.find (name);
 314         if (it != _InstanceMap.end())
 315                 return UInstance (it->second);
 316         else
 317                 return UInstance ();
 318 }
 319
 320 // ***************************************************************************
 321 sint CInstanceGroupUser::getIndexByName(const std::string &name) const
 322 {
 323         map<string,CTransformShape*>::const_iterator it = _InstanceMap.find (name);
 324         if (it == _InstanceMap.end()) return -1;
 325         for(uint k = 0; k < _InstanceGroup._Instances.size(); ++k)
 326         {
 327                 if (_InstanceGroup._Instances[k] == it->second) return (sint) k;
 328         }
 329         return -1;
 330 }
 331
 332
 333 // ***************************************************************************
 334 void CInstanceGroupUser::setBlendShapeFactor (const std::string &bsName, float rFactor)
 335 {
 336         _InstanceGroup.setBlendShapeFactor (bsName, rFactor);
 337 }
 338
 339 // ***************************************************************************
 340
 341 void CInstanceGroupUser::createRoot (UScene &scene)
 342 {
 343         _InstanceGroup.createRoot (((CSceneUser*)&scene)->getScene());
 344 }
 345
 346 // ***************************************************************************
 347 void CInstanceGroupUser::setClusterSystemForInstances (UInstanceGroup *pClusterSystem)
 348 {
 349         _InstanceGroup.setClusterSystemForInstances (&((CInstanceGroupUser*)pClusterSystem)->_InstanceGroup);
 350 }
 351
 352 // ***************************************************************************
 353 bool CInstanceGroupUser::linkToParentCluster(UInstanceGroup *father)
 354 {
 355         if (father)
 356                 return _InstanceGroup.linkToParent(&(NLMISC::safe_cast<CInstanceGroupUser *>(father)->_InstanceGroup));
 357         else
 358         {
 359                 nlwarning("Trying to link a cluster system to a NULL parent cluster");
 360                 return false;
 361         }
 362 }
 363
 364 // ***************************************************************************
 365 void CInstanceGroupUser::getDynamicPortals (std::vector<std::string> &names)
 366 {
 367         _InstanceGroup.getDynamicPortals (names);
 368 }
 369
 370 // ***************************************************************************
 371 void CInstanceGroupUser::setDynamicPortal (std::string& name, bool opened)
 372 {
 373         _InstanceGroup.setDynamicPortal (name, opened);
 374 }
 375
 376 // ***************************************************************************
 377 bool CInstanceGroupUser::getDynamicPortal (std::string& name)
 378 {
 379         return _InstanceGroup.getDynamicPortal (name);
 380 }
 381
 382 // ***************************************************************************
 383 void CInstanceGroupUser::setPos (const NLMISC::CVector &pos)
 384 {
 385         _InstanceGroup.setPos (pos);
 386 }
 387
 388 // ***************************************************************************
 389 void CInstanceGroupUser::setRotQuat (const NLMISC::CQuat &q)
 390 {
 391         _InstanceGroup.setRotQuat (q);
 392 }
 393
 394 // ***************************************************************************
 395 CVector CInstanceGroupUser::getPos ()
 396 {
 397         return _InstanceGroup.getPos ();
 398 }
 399
 400 // ***************************************************************************
 401 CQuat CInstanceGroupUser::getRotQuat ()
 402 {
 403         return _InstanceGroup.getRotQuat();
 404 }
 405
 406
 407 // ***************************************************************************
 408 void                    CInstanceGroupUser::freezeHRC()
 409 {
 410         _InstanceGroup.freezeHRC();
 411 }
 412
 413 // ***************************************************************************
 414 void                    CInstanceGroupUser::unfreezeHRC()
 415 {
 416         _InstanceGroup.unfreezeHRC();
 417 }
 418
 419
 420 // ***************************************************************************
 421 bool                    CInstanceGroupUser::getStaticLightSetup(NLMISC::CRGBA sunAmbient,
 422                 uint retrieverIdentifier, sint surfaceId, const NLMISC::CVector &localPos,
 423                 std::vector<CPointLightInfluence> &pointLightList, uint8 &sunContribution, NLMISC::CRGBA &localAmbient)
 424 {
 425         return _InstanceGroup.getStaticLightSetup(sunAmbient, retrieverIdentifier, surfaceId, localPos, pointLightList,
 426                 sunContribution, localAmbient);
 427 }
 428
 429 // ***************************************************************************
 430 /*virtual*/ void CInstanceGroupUser::setDistMax(uint instance, float dist)
 431 {
 432         if (instance > _InstanceGroup.getNumInstance())
 433         {
 434                 nlwarning("CInstanceGroupUser::setDistMax : instance index %d is invalid", instance);
 435                 return;
 436         }
 437         if (_InstanceGroup._Instances[instance]) _InstanceGroup._Instances[instance]->setDistMax(dist);
 438 }
 439
 440 // ***************************************************************************
 441 /*virtual*/ float CInstanceGroupUser::getDistMax(uint instance) const
 442 {
 443         if (instance > _InstanceGroup.getNumInstance())
 444         {
 445                 nlwarning("CInstanceGroupUser::getDistMax : instance index %d is invalid", instance);
 446                 return -1.f;
 447         }
 448         if (_InstanceGroup._Instances[instance]) return _InstanceGroup._Instances[instance]->getDistMax();
 449         else return -1.f;
 450 }
 451
 452 // ***************************************************************************
 453 /*virtual*/ void CInstanceGroupUser::setCoarseMeshDist(uint instance, float dist)
 454 {
 455         if (instance > _InstanceGroup.getNumInstance())
 456         {
 457                 nlwarning("CInstanceGroupUser::setCoarseMeshDist : instance index %d is invalid", instance);
 458                 return;
 459         }
 460         if (_InstanceGroup._Instances[instance])
 461         {
 462                 CMeshMultiLodInstance *mmli = dynamic_cast<CMeshMultiLodInstance *>(_InstanceGroup._Instances[instance]);
 463                 if (mmli) mmli->setCoarseMeshDist(dist);
 464         }
 465 }
 466
 467 // ***************************************************************************
 468 /*virtual*/ float CInstanceGroupUser::getCoarseMeshDist(uint instance) const
 469 {
 470         if (instance > _InstanceGroup.getNumInstance())
 471         {
 472                 nlwarning("getCoarseMeshDist::getDistMax : instance index %d is invalid", instance);
 473                 return -1.f;
 474         }
 475         if (_InstanceGroup._Instances[instance])
 476         {
 477                 CMeshMultiLodInstance *mmli = dynamic_cast<CMeshMultiLodInstance *>(_InstanceGroup._Instances[instance]);
 478                 if (mmli) return mmli->getCoarseMeshDist();
 479                 else return -1.f;
 480         }
 481         else return -1.f;
 482 }
 483
 484 // ***************************************************************************
 485 UInstance       CInstanceGroupUser::getInstance (uint instanceNb) const
 486 {
 487         if(instanceNb<_InstanceGroup._Instances.size())
 488                 return UInstance (_InstanceGroup._Instances[instanceNb]);
 489         else
 490                 return UInstance ();
 491 }
 492
 493 // ***************************************************************************
 494 void            CInstanceGroupUser::removeInstancesUser()
 495 {
 496         /* ***********************************************
 497          *      WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
 498          *      It can be loaded/called through CAsyncFileManager for instance
 499          * ***********************************************/
 500
 501         // clear the array and the map
 502         _InstanceMap.clear();
 503 }
 504
 505 // ***************************************************************************
 506 UInstanceGroup *CInstanceGroupUser::getParentCluster() const
 507 {
 508         CInstanceGroup  *parent= _InstanceGroup.getParentClusterSystem();
 509         if(parent)
 510                 // NB: return NULL if this is the GlobalInstanceGroup.
 511                 return parent->getUserInterface();
 512         else
 513                 return NULL;
 514 }
 515
 516 // ***************************************************************************
 517 void                    CInstanceGroupUser::displayDebugClusters(UDriver *drv, UTextContext *txtCtx)
 518 {
 519         if(!drv)
 520                 return;
 521         CTextContext    *pTxtCtx= NULL;
 522         if(txtCtx)
 523                 pTxtCtx= &((CTextContextUser*)txtCtx)->getTextContext();
 524         _InstanceGroup.displayDebugClusters(((CDriverUser*)drv)->getDriver(), pTxtCtx);
 525
 526         // restore the matrix context cause of font rendering
 527         ((CDriverUser*)drv)->restoreMatrixContext();
 528 }
 529
 530 // ***************************************************************************
 531 bool                    CInstanceGroupUser::dontCastShadowForInterior(uint instance) const
 532 {
 533         if (instance>=_InstanceGroup.getNumInstance ())
 534                 return false;
 535         return _InstanceGroup.getInstance(instance).DontCastShadowForInterior;
 536 }
 537
 538 // ***************************************************************************
 539 bool                    CInstanceGroupUser::dontCastShadowForExterior(uint instance) const
 540 {
 541         if (instance>=_InstanceGroup.getNumInstance ())
 542                 return false;
 543         return _InstanceGroup.getInstance(instance).DontCastShadowForExterior;
 544 }
 545
 546
 547 } // NL3D