nel/src/3d/scene_user.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2014  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "std3d.h"
  21
  22 #include "nel/3d/u_point_light.h"
  23 #include "nel/3d/u_instance.h"
  24 #include "nel/3d/u_camera.h"
  25 #include "nel/3d/u_skeleton.h"
  26 #include "nel/3d/scene_user.h"
  27 #include "nel/3d/skeleton_model.h"
  28 #include "nel/3d/coarse_mesh_manager.h"
  29 #include "nel/3d/point_light_model.h"
  30 #include "nel/3d/lod_character_manager.h"
  31 #include "nel/3d/lod_character_shape.h"
  32 #include "nel/3d/lod_character_shape_bank.h"
  33 #include "nel/misc/hierarchical_timer.h"
  34 #include "nel/3d/async_texture_manager.h"
  35 #include "nel/3d/water_env_map_user.h"
  36
  37
  38 using namespace NLMISC;
  39
  40 #ifdef DEBUG_NEW
  41 #define new DEBUG_NEW
  42 #endif
  43
  44 namespace NL3D
  45 {
  46
  47 H_AUTO_DECL( NL3D_UI_Scene )
  48 H_AUTO_DECL( NL3D_Misc_Scene_CreateDel_Element )
  49 H_AUTO_DECL( NL3D_CreateOrLoad_Instance )
  50 H_AUTO_DECL( NL3D_CreateOrLoad_Skeleton )
  51 H_AUTO_DECL( NL3D_Load_CLodOrCoarseMesh )
  52 H_AUTO_DECL( NL3D_Load_AsyncIG )
  53
  54 #define NL3D_HAUTO_UI_SCENE                                             H_AUTO_USE( NL3D_UI_Scene )
  55 #define NL3D_HAUTO_ELT_SCENE                                    H_AUTO_USE( NL3D_Misc_Scene_CreateDel_Element )
  56 #define NL3D_HAUTO_CREATE_INSTANCE                              H_AUTO_USE( NL3D_CreateOrLoad_Instance )
  57 #define NL3D_HAUTO_CREATE_SKELETON                              H_AUTO_USE( NL3D_CreateOrLoad_Skeleton )
  58 #define NL3D_HAUTO_LOAD_LOD                                             H_AUTO_USE( NL3D_Load_CLodOrCoarseMesh )
  59 #define NL3D_HAUTO_ASYNC_IG                                             H_AUTO_USE( NL3D_Load_AsyncIG )
  60
  61 // Render/Animate.
  62 H_AUTO_DECL( NL3D_Render_Scene )
  63 H_AUTO_DECL( NL3D_Render_Animate_Scene )
  64 H_AUTO_DECL( NL3D_Render_Scene_Begin )
  65 H_AUTO_DECL( NL3D_Render_Scene_Part )
  66 H_AUTO_DECL( NL3D_Render_Scene_End )
  67
  68 #define NL3D_HAUTO_RENDER_SCENE                                 H_AUTO_USE( NL3D_Render_Scene )
  69 #define NL3D_HAUTO_RENDER_SCENE_ANIMATE                 H_AUTO_USE( NL3D_Render_Animate_Scene )
  70 #define NL3D_HAUTO_RENDER_SCENE_BEGIN                   H_AUTO_USE( NL3D_Render_Scene_Begin )
  71 #define NL3D_HAUTO_RENDER_SCENE_PART                    H_AUTO_USE( NL3D_Render_Scene_Part )
  72 #define NL3D_HAUTO_RENDER_SCENE_END                             H_AUTO_USE( NL3D_Render_Scene_End )
  73
  74
  75
  76
  77 // ***************************************************************************
  78 void                    CSceneUser::setAutomaticAnimationSet(UAnimationSet *as)
  79 {
  80         NL3D_HAUTO_UI_SCENE;
  81
  82         nlassert(as);
  83         as->build();
  84         CAnimationSetUser *asu = NLMISC::safe_cast<CAnimationSetUser *>(as);
  85         _Scene.setAutomaticAnimationSet(asu->_AnimationSet);
  86 }
  87
  88 // ***************************************************************************
  89 UPlayListManager                        *CSceneUser::createPlayListManager()
  90 {
  91         NL3D_HAUTO_ELT_SCENE;
  92
  93         return _PlayListManagers.insert(new CPlayListManagerUser());
  94 }
  95 // ***************************************************************************
  96 void                    CSceneUser::deletePlayListManager(UPlayListManager      *playListManager)
  97 {
  98         NL3D_HAUTO_ELT_SCENE;
  99
 100         _PlayListManagers.erase((CPlayListManagerUser*)playListManager, "deletePlayListManager(): Bad PlayListManager ptr");
 101 }
 102
 103 // ***************************************************************************
 104
 105 void                    CSceneUser::setPolygonBalancingMode(CSceneUser::TPolygonBalancingMode polBalMode)
 106 {
 107         NL3D_HAUTO_UI_SCENE;
 108
 109         nlassert( (uint)CScene::CountPolygonBalancing == (uint)CSceneUser::CountPolygonBalancing );
 110         _Scene.setPolygonBalancingMode((CScene::TPolygonBalancingMode)(uint)(polBalMode));
 111 }
 112
 113 // ***************************************************************************
 114
 115 CSceneUser::TPolygonBalancingMode       CSceneUser::getPolygonBalancingMode() const
 116 {
 117         NL3D_HAUTO_UI_SCENE;
 118
 119         nlassert( (uint)CScene::CountPolygonBalancing == (uint)CSceneUser::CountPolygonBalancing );
 120         return (CSceneUser::TPolygonBalancingMode)(uint)_Scene.getPolygonBalancingMode();
 121 }
 122
 123
 124 // ***************************************************************************
 125 float                   CSceneUser::getNbFaceAsked () const
 126 {
 127         NL3D_HAUTO_UI_SCENE;
 128
 129         return _Scene.getNbFaceAsked ();
 130 }
 131
 132 // ***************************************************************************
 133 void                    CSceneUser::setGroupLoadMaxPolygon(const std::string &group, uint nFaces)
 134 {
 135         NL3D_HAUTO_UI_SCENE;
 136
 137         _Scene.setGroupLoadMaxPolygon(group, nFaces);
 138 }
 139 // ***************************************************************************
 140 uint                    CSceneUser::getGroupLoadMaxPolygon(const std::string &group)
 141 {
 142         NL3D_HAUTO_UI_SCENE;
 143
 144         return _Scene.getGroupLoadMaxPolygon(group);
 145 }
 146 // ***************************************************************************
 147 float                   CSceneUser::getGroupNbFaceAsked (const std::string &group) const
 148 {
 149         NL3D_HAUTO_UI_SCENE;
 150
 151         return _Scene.getGroupNbFaceAsked (group);
 152 }
 153
 154
 155 // ***************************************************************************
 156
 157 void CSceneUser::setCoarseMeshManagerTexture (const char *sPath)
 158 {
 159         NL3D_HAUTO_LOAD_LOD;
 160
 161         // Get the manager
 162         CCoarseMeshManager *manager=_Scene.getCoarseMeshManager ();
 163
 164         // Does it exist ?
 165         if (manager)
 166         {
 167                 // Set the texture
 168                 manager->setTextureFile (sPath);
 169         }
 170 }
 171
 172 // ***************************************************************************
 173 void                            CSceneUser::setCoarseMeshLightingUpdate(uint8 period)
 174 {
 175         NL3D_HAUTO_UI_SCENE;
 176
 177         _Scene.setCoarseMeshLightingUpdate(period);
 178 }
 179
 180 // ***************************************************************************
 181 uint8                           CSceneUser::getCoarseMeshLightingUpdate() const
 182 {
 183         NL3D_HAUTO_UI_SCENE;
 184
 185         return _Scene.getCoarseMeshLightingUpdate();
 186 }
 187
 188 // ***************************************************************************
 189 void                            CSceneUser::enableLightingSystem(bool enable)
 190 {
 191         NL3D_HAUTO_UI_SCENE;
 192
 193         _Scene.enableLightingSystem(enable);
 194 }
 195
 196 // ***************************************************************************
 197 void                            CSceneUser::setAmbientGlobal(NLMISC::CRGBA ambient)
 198 {
 199         NL3D_HAUTO_UI_SCENE;
 200
 201         _Scene.setAmbientGlobal(ambient);
 202 }
 203 void                            CSceneUser::setSunAmbient(NLMISC::CRGBA ambient)
 204 {
 205         NL3D_HAUTO_UI_SCENE;
 206
 207         _Scene.setSunAmbient(ambient);
 208 }
 209 void                            CSceneUser::setSunDiffuse(NLMISC::CRGBA diffuse)
 210 {
 211         NL3D_HAUTO_UI_SCENE;
 212
 213         _Scene.setSunDiffuse(diffuse);
 214 }
 215 void                            CSceneUser::setSunSpecular(NLMISC::CRGBA specular)
 216 {
 217         NL3D_HAUTO_UI_SCENE;
 218
 219         _Scene.setSunSpecular(specular);
 220 }
 221 void                            CSceneUser::setSunDirection(const NLMISC::CVector &direction)
 222 {
 223         NL3D_HAUTO_UI_SCENE;
 224
 225         _Scene.setSunDirection(direction);
 226 }
 227 void                            CSceneUser::setLightGroupColor(uint lightmapGroup, NLMISC::CRGBA color)
 228 {
 229         NL3D_HAUTO_UI_SCENE;
 230
 231         _Scene.setLightGroupColor(lightmapGroup, color);
 232 }
 233
 234
 235 // ***************************************************************************
 236 NLMISC::CRGBA           CSceneUser::getAmbientGlobal() const
 237 {
 238         NL3D_HAUTO_UI_SCENE;
 239
 240         return _Scene.getAmbientGlobal();
 241 }
 242 NLMISC::CRGBA           CSceneUser::getSunAmbient() const
 243 {
 244         NL3D_HAUTO_UI_SCENE;
 245
 246         return _Scene.getSunAmbient();
 247 }
 248 NLMISC::CRGBA           CSceneUser::getSunDiffuse() const
 249 {
 250         NL3D_HAUTO_UI_SCENE;
 251
 252         return _Scene.getSunDiffuse();
 253 }
 254 NLMISC::CRGBA           CSceneUser::getSunSpecular() const
 255 {
 256         NL3D_HAUTO_UI_SCENE;
 257
 258         return _Scene.getSunSpecular();
 259 }
 260 NLMISC::CVector         CSceneUser::getSunDirection() const
 261 {
 262         NL3D_HAUTO_UI_SCENE;
 263
 264         return _Scene.getSunDirection();
 265 }
 266
 267 // ***************************************************************************
 268
 269 void                            CSceneUser::setMaxLightContribution(uint nlights)
 270 {
 271         NL3D_HAUTO_UI_SCENE;
 272
 273         _Scene.setMaxLightContribution(nlights);
 274 }
 275
 276 // ***************************************************************************
 277
 278 uint                            CSceneUser::getMaxLightContribution() const
 279 {
 280         NL3D_HAUTO_UI_SCENE;
 281
 282         return _Scene.getMaxLightContribution();
 283 }
 284
 285 // ***************************************************************************
 286
 287 void                            CSceneUser::setLightTransitionThreshold(float lightTransitionThreshold)
 288 {
 289         NL3D_HAUTO_UI_SCENE;
 290
 291         _Scene.setLightTransitionThreshold(lightTransitionThreshold);
 292 }
 293
 294 // ***************************************************************************
 295
 296 float                           CSceneUser::getLightTransitionThreshold() const
 297 {
 298         NL3D_HAUTO_UI_SCENE;
 299
 300         return _Scene.getLightTransitionThreshold();
 301 }
 302
 303 // ***************************************************************************
 304
 305 UPointLight                     CSceneUser::createPointLight()
 306 {
 307         NL3D_HAUTO_ELT_SCENE;
 308
 309         CTransform      *model= _Scene.createModel(PointLightModelId);
 310         if (model)
 311         {
 312                 CPointLightModel *pointLightModel= safe_cast<CPointLightModel*> (model);
 313                 // If not found, return NULL.
 314                 if(pointLightModel==NULL)
 315                         return NULL;
 316
 317                 // The component is auto added/deleted to _Scene in ctor/dtor.
 318                 return UPointLight (pointLightModel);
 319         }
 320         else
 321                 return UPointLight ();
 322 }
 323
 324 // ***************************************************************************
 325 void                    CSceneUser::deletePointLight(UPointLight &light)
 326 {
 327         NL3D_HAUTO_ELT_SCENE;
 328
 329         // The component is auto added/deleted to _Scene in ctor/dtor.
 330         _Scene.deleteModel (light.getObjectPtr());
 331         light.detach ();
 332 }
 333
 334
 335 // ***************************************************************************
 336 void                    CSceneUser::setGlobalWindPower(float gwp)
 337 {
 338         NL3D_HAUTO_UI_SCENE;
 339
 340         _Scene.setGlobalWindPower(gwp);
 341 }
 342 // ***************************************************************************
 343 float                   CSceneUser::getGlobalWindPower() const
 344 {
 345         NL3D_HAUTO_UI_SCENE;
 346
 347         return _Scene.getGlobalWindPower();
 348 }
 349 // ***************************************************************************
 350 void                    CSceneUser::setGlobalWindDirection(const CVector &gwd)
 351 {
 352         _Scene.setGlobalWindDirection(gwd);
 353 }
 354 // ***************************************************************************
 355 const CVector   &CSceneUser::getGlobalWindDirection() const
 356 {
 357         NL3D_HAUTO_UI_SCENE;
 358
 359         return _Scene.getGlobalWindDirection();
 360 }
 361
 362 // ***************************************************************************
 363 void CSceneUser::updateWaitingIG()
 364 {
 365         for(TWaitingIGList::iterator it = _WaitingIGs.begin(); it != _WaitingIGs.end();)
 366         {
 367                 bool    erased= false;
 368                 if (it->IGToLoad != NULL) // ig loaded ?
 369                 {
 370                         if (it->IGToLoad != (UInstanceGroup *) -1)
 371                         {
 372                                 switch (it->IGToLoad->getAddToSceneState())
 373                                 {
 374                                         case UInstanceGroup::StateNotAdded:
 375                                                 // start loading
 376                                                 if (it->Callback != NULL)
 377                                                         it->Callback->InstanceGroupCreated(it->IGToLoad);
 378                                                 it->IGToLoad->addToSceneAsync(*this, _DriverUser, it->SelectedTexture);
 379                                         break;
 380                                         case UInstanceGroup::StateAdded:
 381                                                 it->IGToLoad->setPos(it->Pos);
 382                                                 it->IGToLoad->setRotQuat(it->Rot);
 383                                                 this->setToGlobalInstanceGroup(it->IGToLoad);
 384                                                 *it->CallerPtr = it->IGToLoad;
 385                                                 // remove from list
 386                                                 it = _WaitingIGs.erase(it);
 387                                                 erased= true;
 388                                         break;
 389                                         case UInstanceGroup::StateError:
 390                                                 delete it->IGToLoad;
 391                                                 it->IGToLoad = (UInstanceGroup *) -1;
 392                                                 *it->CallerPtr = it->IGToLoad;
 393                                                 // remove from list
 394                                                 it = _WaitingIGs.erase(it);
 395                                                 erased= true;
 396                                         break;
 397                                         default:
 398                                         break;
 399                                 }
 400                         }
 401                         else
 402                         {
 403                                 // loading failed
 404                                 *it->CallerPtr = it->IGToLoad;
 405                                 it = _WaitingIGs.erase(it);
 406                                 erased= true;
 407                         }
 408                 }
 409                 // next IG.
 410                 if(!erased)
 411                         it++;
 412         }
 413 }
 414
 415
 416 // ***************************************************************************
 417 void                            CSceneUser::resetCLodManager()
 418 {
 419         NL3D_HAUTO_UI_SCENE;
 420
 421         // DriverUser always setup the lod manager
 422         nlassert(_Scene.getLodCharacterManager());
 423
 424         _Scene.getLodCharacterManager()->reset();
 425 }
 426
 427 // ***************************************************************************
 428 uint32                          CSceneUser::loadCLodShapeBank(const std::string &fileName)
 429 {
 430         NL3D_HAUTO_LOAD_LOD;
 431
 432         // DriverUser always setup the lod manager
 433         nlassert(_Scene.getLodCharacterManager());
 434
 435         // Open the file
 436         CIFile  file(CPath::lookup(fileName));
 437
 438         // create the shape bank
 439         uint32  bankId= _Scene.getLodCharacterManager()->createShapeBank();
 440
 441         // get the bank
 442         CLodCharacterShapeBank  *bank= _Scene.getLodCharacterManager()->getShapeBank(bankId);
 443         nlassert(bank);
 444
 445         // read the bank.
 446         file.serial(*bank);
 447
 448         // recompile the shape Map.
 449         _Scene.getLodCharacterManager()->compile();
 450
 451         return bankId;
 452 }
 453
 454 // ***************************************************************************
 455 void                            CSceneUser::deleteCLodShapeBank(uint32 bankId)
 456 {
 457         NL3D_HAUTO_LOAD_LOD;
 458
 459         // DriverUser always setup the lod manager
 460         nlassert(_Scene.getLodCharacterManager());
 461
 462         // delete the bank
 463         _Scene.getLodCharacterManager()->deleteShapeBank(bankId);
 464
 465         // recompile the shape Map.
 466         _Scene.getLodCharacterManager()->compile();
 467 }
 468
 469 // ***************************************************************************
 470 sint32                          CSceneUser::getCLodShapeIdByName(const std::string &name) const
 471 {
 472         NL3D_HAUTO_UI_SCENE;
 473
 474         // DriverUser always setup the lod manager
 475         nlassert(_Scene.getLodCharacterManager());
 476
 477         return _Scene.getLodCharacterManager()->getShapeIdByName(name);
 478 }
 479
 480 // ***************************************************************************
 481 sint32                          CSceneUser::getCLodAnimIdByName(uint32 shapeId, const std::string &name) const
 482 {
 483         NL3D_HAUTO_UI_SCENE;
 484
 485         // DriverUser always setup the lod manager
 486         nlassert(_Scene.getLodCharacterManager());
 487
 488         const CLodCharacterShape        *shape= _Scene.getLodCharacterManager()->getShape(shapeId);
 489         if(shape)
 490                 return shape->getAnimIdByName(name);
 491         else
 492                 return -1;
 493 }
 494
 495
 496 // ***************************************************************************
 497 void                    CSceneUser::render(bool updateWaitingInstancesFlag /*= true*/, bool restoreMatrixContextAfterRender /*= true*/)
 498 {
 499
 500         // render the scene.
 501         {
 502                 NL3D_HAUTO_RENDER_SCENE
 503
 504                 if(_Scene.getCam() == NULL)
 505                         nlerror("render(): try to render with no camera linked (may have been deleted)");
 506                 _Scene.render(true);
 507         }
 508
 509         if (updateWaitingInstancesFlag) updateWaitingInstances();
 510
 511         // Must restore the matrix context, so 2D/3D interface not disturbed.
 512         if (restoreMatrixContextAfterRender) _DriverUser->restoreMatrixContext();
 513 }
 514
 515 // ***************************************************************************
 516 void                    CSceneUser::beginPartRender()
 517 {
 518
 519         // render the scene.
 520         {
 521                 NL3D_HAUTO_RENDER_SCENE_BEGIN
 522                 _Scene.beginPartRender();
 523         }
 524 }
 525
 526 // ***************************************************************************
 527 void                    CSceneUser::renderPart(TRenderPart rp, bool doHrcPass, bool doTrav, bool keepTrav)
 528 {
 529
 530         // render the scene.
 531         {
 532                 NL3D_HAUTO_RENDER_SCENE_PART
 533
 534                 if(_Scene.getCam() == NULL)
 535                         nlerror("render(): try to render with no camera linked (may have been deleted)");
 536                 _Scene.renderPart(rp, doHrcPass, doTrav, keepTrav);
 537         }
 538 }
 539
 540 // ***************************************************************************
 541 void                    CSceneUser::endPartRender(bool updateWaitingInstancesFlag, bool restoreMatrixContextAfterRender, bool keepTrav)
 542 {
 543
 544         // render the scene.
 545         {
 546                 NL3D_HAUTO_RENDER_SCENE_END
 547                 _Scene.endPartRender(keepTrav);
 548         }
 549
 550         if (updateWaitingInstancesFlag) updateWaitingInstances();
 551
 552         // Must restore the matrix context, so 2D/3D interface not disturbed.
 553         if (restoreMatrixContextAfterRender) _DriverUser->restoreMatrixContext();
 554 }
 555
 556
 557 // ***************************************************************************
 558 /*virtual*/ void CSceneUser::updateWaitingInstances(double ellapsedTime)
 559 {
 560         _Scene.updateWaitingInstances(ellapsedTime);
 561         updateWaitingInstances();
 562 }
 563
 564
 565 // ***************************************************************************
 566 void CSceneUser::updateWaitingInstances()
 567 {
 568         // Update waiting instances
 569         {
 570                 NL3D_HAUTO_ASYNC_IG
 571
 572                 // Done after the _Scene.render because in this method the instance are checked for creation
 573                 std::map<UInstance*,CTransformShape*>::iterator it = _WaitingInstances.begin();
 574                 while( it != _WaitingInstances.end() )
 575                 {
 576                         if( it->second != NULL )
 577                         {
 578                                 it->first->attach (it->second);
 579                                 std::map<UInstance*,CTransformShape*>::iterator delIt = it;
 580                                 ++it;
 581                                 _WaitingInstances.erase(delIt);
 582                         }
 583                         else
 584                         {
 585                                 ++it;
 586                         }
 587                 }
 588         }
 589
 590         // update waiting instances groups;
 591         {
 592                 NL3D_HAUTO_ASYNC_IG
 593
 594                 updateWaitingIG();
 595         }
 596 }
 597
 598
 599 void                    CSceneUser::animate(TGlobalAnimationTime time)
 600 {
 601         NL3D_HAUTO_RENDER_SCENE_ANIMATE;
 602
 603         _Scene.animate(time);
 604 }
 605
 606 // ***************************************************************************
 607
 608 void                    CSceneUser::setCam(UCamera cam)
 609 {
 610         NL3D_HAUTO_UI_SCENE;
 611
 612         if(cam.empty())
 613                 nlerror("setCam(): cannot set a NULL camera");
 614         CCamera *camera = cam.getObjectPtr();
 615         if( camera->getOwnerScene() != &_Scene)
 616                 nlerror("setCam(): try to set a current camera not created from this scene");
 617
 618         _Scene.setCam(camera);
 619 }
 620
 621 // ***************************************************************************
 622
 623 UCamera                 CSceneUser::getCam()
 624 {
 625         NL3D_HAUTO_UI_SCENE;
 626
 627         return UCamera (_Scene.getCam());
 628 }
 629
 630 // ***************************************************************************
 631
 632 void                    CSceneUser::setViewport(const class CViewport& viewport)
 633 {
 634         NL3D_HAUTO_UI_SCENE;
 635
 636         _Scene.setViewport(viewport);
 637 }
 638 CViewport               CSceneUser::getViewport()
 639 {
 640         NL3D_HAUTO_UI_SCENE;
 641
 642         return _Scene.getViewport();
 643 }
 644
 645 UInstanceGroup  *CSceneUser::findCameraClusterSystemFromRay(UInstanceGroup *startClusterSystem,
 646                         const NLMISC::CVector &startPos, NLMISC::CVector &endPos)
 647 {
 648         NL3D_HAUTO_UI_SCENE;
 649
 650         CInstanceGroupUser      *uig= dynamic_cast<CInstanceGroupUser*>(startClusterSystem);
 651         CInstanceGroup          *pIg= NULL;
 652         if(uig)
 653                 pIg= &uig->_InstanceGroup;
 654
 655         CInstanceGroup *resultIg= _Scene.findCameraClusterSystemFromRay(pIg, startPos, endPos);
 656         if(resultIg)
 657                 return resultIg->getUserInterface();
 658         else
 659                 return NULL;
 660 }
 661
 662 // ***************************************************************************
 663
 664 UCamera                 CSceneUser::createCamera()
 665 {
 666         NL3D_HAUTO_ELT_SCENE;
 667
 668         CTransform      *model= _Scene.createModel(CameraId);
 669         if (model)
 670         {
 671                 CCamera *object = NLMISC::safe_cast<CCamera*>(model);
 672                 object->setFrustum(UCamera::DefLx, UCamera::DefLy, UCamera::DefLzNear, UCamera::DefLzFar);
 673                 return UCamera (object);
 674         }
 675         else
 676                 return UCamera ();
 677 }
 678
 679 // ***************************************************************************
 680
 681 void                    CSceneUser::deleteCamera(UCamera &cam)
 682 {
 683         NL3D_HAUTO_ELT_SCENE;
 684
 685         CCamera         *object = cam.getObjectPtr();
 686
 687         // The component is auto added/deleted to _Scene in ctor/dtor.
 688         _Scene.deleteModel (object);
 689         cam.detach ();
 690 }
 691
 692 // ***************************************************************************
 693
 694 UInstance               CSceneUser::createInstance(const std::string &shapeName)
 695 {
 696         NL3D_HAUTO_CREATE_INSTANCE;
 697
 698         CTransformShape *model= _Scene.createInstance(shapeName);
 699         return UInstance (model);
 700 }
 701
 702 // ***************************************************************************
 703
 704 void CSceneUser::createInstanceAsync(const std::string &shapeName, UInstance *ppInstance, const NLMISC::CVector &position, uint selectedTexture)
 705 {
 706         NL3D_HAUTO_CREATE_INSTANCE;
 707
 708         _WaitingInstances[ppInstance] = NULL;
 709         _Scene.createInstanceAsync(shapeName,&_WaitingInstances[ppInstance], position, selectedTexture);
 710 //              CTransform      *model= _Scene.createInstance(shapeName);
 711         // If not found, return NULL.
 712 //              if(model==NULL)
 713 //                      return NULL;
 714
 715 //              if( dynamic_cast<CMeshInstance*>(model)==NULL )
 716 //                      nlerror("UScene::createInstance(): shape is not a mesh");
 717
 718         // The component is auto added/deleted to _Scene in ctor/dtor.
 719 //              return dynamic_cast<UInstance*>( _Transforms.insert(new CInstanceUser(&_Scene, model)) );
 720 }
 721
 722 // ***************************************************************************
 723
 724 void                    CSceneUser::deleteInstance(UInstance &inst)
 725 {
 726         NL3D_HAUTO_ELT_SCENE;
 727
 728         _Scene.deleteInstance (inst.getObjectPtr());
 729         inst.detach ();
 730 }
 731
 732 // ***************************************************************************
 733
 734 void CSceneUser::createInstanceGroupAndAddToSceneAsync (const std::string &instanceGroup, UInstanceGroup **pIG, const NLMISC::CVector &pos, const NLMISC::CQuat &rot,
 735                                                                                                                 uint selectedTexture, IAsyncLoadCallback *pCB)
 736 {
 737         NL3D_HAUTO_ASYNC_IG;
 738
 739         _WaitingIGs.push_front(CWaitingIG(pIG, pos, rot, selectedTexture, pCB));
 740         UInstanceGroup::createInstanceGroupAsync(instanceGroup, &(_WaitingIGs.begin()->IGToLoad));
 741         // this list updat will be performed at each render, see updateWaitingIG
 742 }
 743
 744 void CSceneUser::stopCreatingAndAddingIG(UInstanceGroup **pIG)
 745 {
 746         NL3D_HAUTO_ASYNC_IG;
 747
 748         for(TWaitingIGList::iterator it = _WaitingIGs.begin(); it != _WaitingIGs.end(); ++it)
 749         {
 750                 CWaitingIG &rWIG = *it;
 751                 if (rWIG.CallerPtr == pIG)
 752                 {
 753                         if (rWIG.IGToLoad == NULL)
 754                         {
 755                                 UInstanceGroup::stopCreateInstanceGroupAsync(pIG);
 756                         }
 757                         // Ig must be initialized
 758                         else if (rWIG.IGToLoad != (UInstanceGroup*)-1)
 759                         {
 760                                 switch(rWIG.IGToLoad->getAddToSceneState())
 761                                 {
 762                                         case UInstanceGroup::StateAdding:
 763                                                 rWIG.IGToLoad->stopAddToSceneAsync();
 764                                         break;
 765                                         case UInstanceGroup::StateAdded:
 766                                                 rWIG.IGToLoad->removeFromScene(*this);
 767                                                 delete rWIG.IGToLoad;
 768                                         break;
 769                                         case UInstanceGroup::StateNotAdded:
 770                                                 delete rWIG.IGToLoad;
 771                                         break;
 772                                         default:
 773                                         break;
 774                                 }
 775                         }
 776                         _WaitingIGs.erase(it);
 777                         return;
 778                 }
 779         }
 780 }
 781
 782 void CSceneUser::deleteInstanceGroup(UInstanceGroup *pIG)
 783 {
 784         delete pIG;
 785 }
 786
 787 // ***************************************************************************
 788
 789 UTransform CSceneUser::createTransform()
 790 {
 791         NL3D_HAUTO_ELT_SCENE;
 792
 793         CTransform      *model= _Scene.createModel(TransformId);
 794         return UTransform (model);
 795 }
 796
 797 // ***************************************************************************
 798
 799 void                    CSceneUser::deleteTransform(UTransform &tr)
 800 {
 801         NL3D_HAUTO_ELT_SCENE;
 802
 803         _Scene.deleteModel (tr.getObjectPtr());
 804         tr.detach ();
 805 }
 806
 807 // ***************************************************************************
 808
 809 USkeleton               CSceneUser::createSkeleton(const std::string &shapeName)
 810 {
 811         NL3D_HAUTO_CREATE_SKELETON;
 812
 813         CTransformShape *ts = _Scene.createInstance(shapeName);
 814         if (ts)
 815         {
 816                 CSkeletonModel  *model= safe_cast<CSkeletonModel*> (ts);
 817                 return USkeleton (model);
 818         }
 819         else
 820         {
 821                 return USkeleton ();
 822         }
 823 }
 824
 825 // ***************************************************************************
 826
 827 void                    CSceneUser::deleteSkeleton(USkeleton &skel)
 828 {
 829         NL3D_HAUTO_ELT_SCENE;
 830
 831         // The component is auto added/deleted to _Scene in ctor/dtor.
 832         _Scene.deleteInstance (skel.getObjectPtr());
 833         skel.detach ();
 834 }
 835
 836 // ***************************************************************************
 837
 838 ULandscape              *CSceneUser::createLandscape()
 839 {
 840         NL3D_HAUTO_ELT_SCENE;
 841
 842         // The component is auto added/deleted to _Scene in ctor/dtor.
 843         return _Landscapes.insert(new CLandscapeUser(&_Scene));
 844 }
 845 void                    CSceneUser::deleteLandscape(ULandscape *land)
 846 {
 847         NL3D_HAUTO_ELT_SCENE;
 848
 849         // The component is auto added/deleted to _Scene in ctor/dtor.
 850         _Landscapes.erase((CLandscapeUser*) land);
 851 }
 852
 853 UCloudScape *CSceneUser::createCloudScape()
 854 {
 855         NL3D_HAUTO_ELT_SCENE;
 856
 857         // The component is auto added/deleted to _Scene in ctor/dtor.
 858         return _CloudScapes.insert(new CCloudScapeUser(&_Scene));
 859 }
 860 void CSceneUser::deleteCloudScape(UCloudScape *cs)
 861 {
 862
 863         // The component is auto added/deleted to _Scene in ctor/dtor.
 864         _CloudScapes.erase((CCloudScapeUser*) cs);
 865 }
 866 /*
 867
 868 UInstanceGroup  *CSceneUser::createInstanceGroup (const std::string &instanceGroup)
 869 {
 870         // Create the instance group
 871         CInstanceGroupUser *user=new CInstanceGroupUser;
 872
 873         // Init the class
 874         if (!user->load (instanceGroup))
 875         {
 876                 // Prb, erase it
 877                 delete user;
 878
 879                 // Return error code
 880                 return NULL;
 881         }
 882
 883         // Insert the pointer in the pointer list
 884         _InstanceGroups.insert (user);
 885
 886         // return the good value
 887         return user;
 888 }
 889
 890 void                    CSceneUser::deleteInstanceGroup (UInstanceGroup *group)
 891 {
 892         // The component is auto added/deleted to _Scene in ctor/dtor.
 893         _InstanceGroups.erase (dynamic_cast<CInstanceGroupUser*>(group));
 894 }
 895 */
 896
 897 void CSceneUser::setToGlobalInstanceGroup(UInstanceGroup *pIG)
 898 {
 899         NL3D_HAUTO_UI_SCENE;
 900
 901         CInstanceGroupUser *pIGU = (CInstanceGroupUser*)pIG;
 902         pIGU->_InstanceGroup.setClusterSystemForInstances(_Scene.getGlobalInstanceGroup());
 903 }
 904
 905 // ***************************************************************************
 906 UVisualCollisionManager         *CSceneUser::createVisualCollisionManager()
 907 {
 908         NL3D_HAUTO_ELT_SCENE;
 909
 910         return _VisualCollisionManagers.insert(new CVisualCollisionManagerUser);
 911 }
 912 void                                            CSceneUser::deleteVisualCollisionManager(UVisualCollisionManager *mgr)
 913 {
 914         NL3D_HAUTO_ELT_SCENE;
 915
 916         CVisualCollisionManagerUser     *vcmUser= dynamic_cast<CVisualCollisionManagerUser*>(mgr);
 917
 918         // if it was the one used for shadow receiving in this scene, then set NULL
 919         if(_Scene.getVisualCollisionManagerForShadow()==&vcmUser->getVCM())
 920                 _Scene.setVisualCollisionManagerForShadow(NULL);
 921
 922         // and delete it
 923         _VisualCollisionManagers.erase(vcmUser);
 924 }
 925
 926
 927 // ***************************************************************************
 928 CSceneUser::CSceneUser(CDriverUser *drv, bool bSmallScene) : _Scene(bSmallScene)
 929 {
 930         nlassert(drv);
 931         _DriverUser= drv;
 932
 933         // init default Roots.
 934         _Scene.initDefaultRoots();
 935
 936         // Set driver.
 937         _Scene.setDriver(_DriverUser->getDriver());
 938
 939         // Set viewport
 940         _Scene.setViewport (CViewport());
 941
 942         // init QuadGridClipManager
 943         _Scene.initQuadGridClipManager ();
 944
 945         // Create default camera, and active!!
 946         setCam(createCamera());
 947
 948         _WaterEnvMap = NULL;
 949 }
 950
 951 CSceneUser::~CSceneUser()
 952 {
 953         _VisualCollisionManagers.clear();
 954         _Landscapes.clear();
 955         _CloudScapes.clear();
 956         _Scene.release();
 957         _Scene.setDriver(NULL);
 958         _Scene.setCam(NULL);
 959         _DriverUser= NULL;
 960 }
 961
 962 // ***************************************************************************
 963 void            CSceneUser::setMaxSkeletonsInNotCLodForm(uint m)
 964 {
 965         _Scene.setMaxSkeletonsInNotCLodForm(m);
 966 }
 967
 968 // ***************************************************************************
 969 uint            CSceneUser::getMaxSkeletonsInNotCLodForm() const
 970 {
 971         return _Scene.getMaxSkeletonsInNotCLodForm();
 972 }
 973
 974
 975 // ***************************************************************************
 976 void            CSceneUser::enableElementRender(TRenderFilter elt, bool state)
 977 {
 978         _Scene.enableElementRender(elt, state);
 979 }
 980
 981
 982 // ***************************************************************************
 983 void            CSceneUser::profileNextRender()
 984 {
 985         _Scene.profileNextRender();
 986 }
 987 // ***************************************************************************
 988 void            CSceneUser::getProfileResults(CBenchResults &results)
 989 {
 990         // Fill profile results
 991         results= _Scene.BenchRes;
 992 }
 993
 994 // ***************************************************************************
 995 void            CSceneUser::profileQuadGridClipManager()
 996 {
 997         _Scene.getClipTrav().getQuadGridClipManager()->profile();
 998 }
 999
1000 // ***************************************************************************
1001 uint CSceneUser::getNumFlareContexts() const
1002 {
1003         return CScene::MaxNumFlareContexts;
1004 }
1005
1006 // ***************************************************************************
1007 void CSceneUser::setFlareContext(uint context)
1008 {
1009         if (context >= CScene::MaxNumFlareContexts)
1010         {
1011                 nlwarning("Invalid flare context");
1012                 return;
1013         }
1014         _Scene.setFlareContext(context);
1015 }
1016
1017 // ***************************************************************************
1018 uint CSceneUser::getFlareContext() const
1019 {
1020         return _Scene.getFlareContext();
1021 }
1022
1023
1024 // ***************************************************************************
1025 uint                    CSceneUser::getShadowMapTextureSize() const
1026 {
1027         return _Scene.getShadowMapTextureSize();
1028 }
1029
1030 // ***************************************************************************
1031 void                    CSceneUser::setShadowMapTextureSize(uint size)
1032 {
1033         _Scene.setShadowMapTextureSize(size);
1034 }
1035
1036 // ***************************************************************************
1037 uint                    CSceneUser::getShadowMapBlurSize() const
1038 {
1039         return _Scene.getShadowMapBlurSize();
1040 }
1041
1042 // ***************************************************************************
1043 void                    CSceneUser::setShadowMapBlurSize(uint bs)
1044 {
1045         _Scene.setShadowMapBlurSize(bs);
1046 }
1047
1048 // ***************************************************************************
1049 void                    CSceneUser::enableShadowPolySmooth(bool enable)
1050 {
1051         _Scene.enableShadowPolySmooth(enable);
1052 }
1053
1054 // ***************************************************************************
1055 bool                    CSceneUser::getEnableShadowPolySmooth() const
1056 {
1057         return _Scene.getEnableShadowPolySmooth();
1058 }
1059
1060 // ***************************************************************************
1061 void                    CSceneUser::setShadowMapDistFadeStart(float dist)
1062 {
1063         _Scene.setShadowMapDistFadeStart(dist);
1064 }
1065 // ***************************************************************************
1066 float                   CSceneUser::getShadowMapDistFadeStart() const
1067 {
1068         return _Scene.getShadowMapDistFadeStart();
1069 }
1070 // ***************************************************************************
1071 void                    CSceneUser::setShadowMapDistFadeEnd(float dist)
1072 {
1073         _Scene.setShadowMapDistFadeEnd(dist);
1074 }
1075 // ***************************************************************************
1076 float                   CSceneUser::getShadowMapDistFadeEnd() const
1077 {
1078         return _Scene.getShadowMapDistFadeEnd();
1079 }
1080 // ***************************************************************************
1081 void                    CSceneUser::setShadowMapMaxCasterInScreen(uint num)
1082 {
1083         _Scene.setShadowMapMaxCasterInScreen(num);
1084 }
1085 // ***************************************************************************
1086 uint                    CSceneUser::getShadowMapMaxCasterInScreen() const
1087 {
1088         return _Scene.getShadowMapMaxCasterInScreen();
1089 }
1090 // ***************************************************************************
1091 void                    CSceneUser::setShadowMapMaxCasterAround(uint num)
1092 {
1093         _Scene.setShadowMapMaxCasterAround(num);
1094 }
1095 // ***************************************************************************
1096 uint                    CSceneUser::getShadowMapMaxCasterAround() const
1097 {
1098         return _Scene.getShadowMapMaxCasterAround();
1099 }
1100 // ***************************************************************************
1101 void                    CSceneUser::setVisualCollisionManagerForShadow(UVisualCollisionManager *vcm)
1102 {
1103         if(vcm==NULL)
1104                 _Scene.setVisualCollisionManagerForShadow(NULL);
1105         else
1106         {
1107                 CVisualCollisionManagerUser     *vcmUser= static_cast<CVisualCollisionManagerUser*>(vcm);
1108                 _Scene.setVisualCollisionManagerForShadow(&vcmUser->getVCM());
1109         }
1110 }
1111 // ***************************************************************************
1112 void CSceneUser::setWaterCallback(IWaterSurfaceAddedCallback *wcb)
1113 {
1114         _Scene.setWaterCallback(wcb);
1115 }
1116 // ***************************************************************************
1117 IWaterSurfaceAddedCallback *CSceneUser::getWaterCallback() const
1118 {
1119         return _Scene.getWaterCallback();
1120 }
1121 // ***************************************************************************
1122 void CSceneUser::setLandscapePolyDrawingCallback(ILandscapePolyDrawingCallback *lpd)
1123 {
1124         _Scene.setLandscapePolyDrawingCallback(lpd);
1125 }
1126 // ***************************************************************************
1127 ILandscapePolyDrawingCallback *CSceneUser::getLandscapePolyDrawingCallback() const
1128 {
1129         return _Scene.getLandscapePolyDrawingCallback();
1130 }
1131 // ***************************************************************************
1132 void CSceneUser::setupTransparencySorting(uint8 maxPriority /*=0*/,uint NbDistanceEntries /*=1024*/)
1133 {
1134         _Scene.getRenderTrav().setupTransparencySorting(maxPriority, NbDistanceEntries);
1135 }
1136
1137 // ***************************************************************************
1138 void CSceneUser::setWaterEnvMap(UWaterEnvMap *waterEnvMap)
1139 {
1140         if (waterEnvMap)
1141         {
1142                 if (((CWaterEnvMapUser *) waterEnvMap)->EnvMap.Driver != _DriverUser)
1143                 {
1144                         nlwarning("Water envmap can only be set in a scene that was created from the same driver");
1145                         return;
1146                 }
1147         }
1148         _Scene.setWaterEnvMap(&((CWaterEnvMapUser *) waterEnvMap)->EnvMap);
1149         _WaterEnvMap = waterEnvMap;
1150 }
1151
1152
1153 // ***************************************************************************
1154 void CSceneUser::updateWaterEnvMaps(TGlobalAnimationTime time)
1155 {
1156         _Scene.updateWaterEnvMaps(time);
1157 }
1158
1159
1160
1161
1162 } // NL3D