ryzom/client/src/r2/displayer_visual.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2013  Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
   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 "stdpch.h"
  21 #include "displayer_visual.h"
  22 // r2
  23 #include "instance.h"
  24 #include "editor.h"
  25 #include "tool_select_move.h"
  26 //
  27 #include "nel/misc/algo.h"
  28 #include "nel/misc/vector_2f.h"
  29 //
  30 #include "../time_client.h"
  31 #include "nel/gui/lua_ihm.h"
  32 #include "../global.h"
  33 //
  34 #include "../interface_v3/interface_manager.h"
  35 #include "../interface_v3/group_in_scene.h"
  36 //
  37 #include "r2_config.h"
  38
  39 #ifdef DEBUG_NEW
  40 #define new DEBUG_NEW
  41 #endif
  42
  43 using namespace NLMISC;
  44
  45 extern uint     SkipFrame;
  46
  47 namespace R2
  48 {
  49
  50
  51 // ***************************************************************
  52 CDisplayerVisual::CDisplayerVisual() : _DisplayFlags(FlagNone)
  53 {
  54         _BlinkStartDate = 0;
  55         _Pos.set(0, 0, 0);
  56         _WorldPos = _Pos;
  57         _IconInScene = NULL;
  58         _IconInSceneCreationFailed = false;
  59         _DisplayFlags = 0;
  60         _RotateInProgress = false;
  61         _MoveInProgress = false;
  62         // TODO nico : optim here : only one decal used at a time
  63         _LastCamDist = -100.f;
  64         _DisplayMode = DisplayModeVisible;
  65         _InheritDisplayMode = false; // filled at init by this displayer lua parameter
  66         _LastParentOk = false;
  67         _LastParent = NULL;
  68 }
  69
  70 // ***************************************************************
  71 CDisplayerVisual::~CDisplayerVisual()
  72 {
  73         if (_IconInScene)
  74         {
  75                 CWidgetManager::getInstance()->unMakeWindow(_IconInScene);
  76                 if (_IconInScene->getParent())
  77                 {
  78                         _IconInScene->getParent()->delGroup(_IconInScene);
  79                 }
  80                 else
  81                 {
  82                         delete _IconInScene;
  83                 }
  84         }
  85 }
  86
  87 // ***************************************************************
  88 void CDisplayerVisual::setDisplayFlag(TDisplayFlags flag, bool on)
  89 {
  90         //H_AUTO(R2_CDisplayerVisual_setDisplayFlag)
  91         nlctassert(FlagCount <= 32);
  92         nlassert((uint) flag < FlagCount);
  93         setFlags(_DisplayFlags, 1 << flag, on);
  94 }
  95
  96 // ***************************************************************
  97 bool CDisplayerVisual::getDisplayFlag(TDisplayFlags flag) const
  98 {
  99         //H_AUTO(R2_CDisplayerVisual_getDisplayFlag)
 100         nlctassert(FlagCount <= 32);
 101         nlassert((uint) flag < FlagCount);
 102         return (_DisplayFlags & (1 << flag)) != 0;
 103 }
 104
 105 // ***************************************************************
 106 CDisplayerVisual *CDisplayerVisual::getParent()
 107 {
 108         if (_LastParentOk) return _LastParent;
 109         CDisplayerVisual *result = NULL;
 110         //H_AUTO(R2_CDisplayerVisual_getParent)
 111         CInstance *inst = getDisplayedInstance();
 112         nlassert(inst);
 113         CInstance *parentInstance = inst->getParent();
 114         if (parentInstance)
 115         {
 116                 result = parentInstance->getDisplayerVisual();
 117         }
 118         _LastParent = result;
 119         _LastParentOk = true;
 120         return result;
 121 }
 122
 123 // ***************************************************************
 124 const CDisplayerVisual *CDisplayerVisual::getParent() const
 125 {
 126         //H_AUTO(R2_CDisplayerVisual_getParent)
 127         return (const_cast<CDisplayerVisual *>(this))->getParent();
 128         /*CInstance *inst = getDisplayedInstance();
 129         nlassert(inst);
 130         CInstance *parentInstance = inst->getParent();
 131         if (parentInstance)
 132         {
 133                 return parentInstance->getDisplayerVisual();
 134         }
 135         return NULL;*/
 136 }
 137
 138 // ***************************************************************
 139 void CDisplayerVisual::onFocus(bool focused)
 140 {
 141         //H_AUTO(R2_CDisplayerVisual_onFocus)
 142         setDisplayFlag(FlagHasFocus, focused);
 143 }
 144
 145 // ***************************************************************
 146 void CDisplayerVisual::onSelect(bool selected)
 147 {
 148         //H_AUTO(R2_CDisplayerVisual_onSelect)
 149         setDisplayFlag(FlagSelected, selected);
 150 }
 151
 152 // ***************************************************************
 153 void CDisplayerVisual::onPostHrcMove()
 154 {
 155         //H_AUTO(R2_CDisplayerVisual_onPostHrcMove)
 156         _LastParentOk = false; // must update parent
 157         updateWorldPosRecurse();
 158 }
 159
 160
 161 // ***************************************************************
 162 void CDisplayerVisual::blink()
 163 {
 164         //H_AUTO(R2_CDisplayerVisual_blink)
 165         _BlinkStartDate = T1;
 166 }
 167
 168 // ***************************************************************
 169 int CDisplayerVisual::luaBlink(CLuaState &ls)
 170 {
 171         //H_AUTO(R2_CDisplayerVisual_luaBlink)
 172         CLuaIHM::checkArgCount(ls,   "luaBlink", 1);
 173         blink();
 174         return 0;
 175 }
 176
 177 // ***************************************************************
 178 NLMISC::CRGBA CDisplayerVisual::getBlinkColor(NLMISC::CRGBA defaultColor,  NLMISC::CRGBA blinkColor) const
 179 {
 180         //H_AUTO(R2_NLMISC_CRGBA )
 181         const uint NUM_BLINKS = 3;
 182         const uint BLINK_LENGTH_IN_MS = 100;
 183         sint64 blink = (T1 - _BlinkStartDate) / BLINK_LENGTH_IN_MS;
 184         if (blink > NUM_BLINKS) return defaultColor;
 185         return !(blink & 1) ? blinkColor : defaultColor;
 186 }
 187
 188 // *********************************************************************************************************
 189 void CDisplayerVisual::onAttrModified(const std::string &attrName,  sint32 /* attrIndex */)
 190 {
 191         //H_AUTO(R2_CDisplayerVisual_onAttrModified)
 192         if (attrName == "Position")
 193         {
 194                 updatePos();
 195         }
 196         /*else if (attrName == "DisplayMode")
 197         {
 198                 updateDisplayMode();
 199                 uint numSons = getNumSons();
 200                 for(uint k = 0; k < numSons; ++k)
 201                 {
 202                         CDisplayerVisual *dv = getSon(k);
 203                         if (dv)
 204                         {
 205                                 dv->onParentDisplayModeChanged();
 206                         }
 207                 }
 208         }*/
 209 }
 210
 211
 212 // *********************************************************************************************************
 213 /*void CDisplayerVisual::updateDisplayMode()
 214 {
 215         sint value = (sint) getNumber(&getProps(), "DisplayMode");
 216         if (value >= 0 && value < DisplayModeCount)
 217         {
 218                 TDisplayMode newDisplayMode = (TDisplayMode) value;
 219                 if (newDisplayMode != _DisplayMode)
 220                 {
 221                         //if (newDisplayMode == DisplayModeFrozen && getEditor().getSelectedInstance() == getDisplayedInstance())
 222                         //{
 223                         //      getEditor().setSelectedInstance(NULL);
 224                         //}
 225                         //_DisplayMode = newDisplayMode;
 226                 }
 227         }
 228         else
 229         {
 230                 nlwarning("Trying to set an invalid display mode : %d", (int) _DisplayMode);
 231         }
 232 }*/
 233
 234 // *********************************************************************************************************
 235 void CDisplayerVisual::updatePos()
 236 {
 237         //H_AUTO(R2_CDisplayerVisual_updatePos)
 238         updateLocalPos();
 239         updateWorldPosRecurse();
 240 }
 241
 242 // *********************************************************************************************************
 243 void CDisplayerVisual::updateLocalPos()
 244 {
 245         //H_AUTO(R2_CDisplayerVisual_updateLocalPos)
 246         if (getProps().findAttr("Position"))
 247         {
 248                 _Pos = getVector(getObject(&getProps(), "Position"));
 249                 static volatile bool wantAssert = true;
 250                 if (!isValidDouble(_Pos.x) || !isValidDouble(_Pos.y) ||!isValidDouble(_Pos.z))
 251                 {
 252 //                      nlassert(!wantAssert);
 253                         BOMB_IF(wantAssert,"'wantAssert' was triggered",_Pos.set(0, 0, 0));
 254                 }
 255         }
 256         else
 257         {
 258                 _Pos.set(0, 0, 0);
 259         }
 260 }
 261
 262 // *********************************************************************************************************
 263 bool CDisplayerVisual::inheritPos() const
 264 {
 265         //H_AUTO(R2_CDisplayerVisual_inheritPos)
 266         return getNumber(&getProps(), "InheritPos") != 0;
 267 }
 268
 269 // *********************************************************************************************************
 270 void CDisplayerVisual::updateWorldPos()
 271 {
 272         //H_AUTO(R2_CDisplayerVisual_updateWorldPos)
 273         CDisplayerVisual *parent = getParent();
 274         if (parent && inheritPos())
 275         {
 276                 _WorldPos = parent->getWorldPos() + _Pos;
 277         }
 278         else
 279         {
 280                 _WorldPos = _Pos;
 281         }
 282         static volatile bool wantAssert = true;
 283         if (!isValidDouble(_WorldPos.x) || !isValidDouble(_WorldPos.y) ||!isValidDouble(_WorldPos.z))
 284         {
 285                 nlassert(!wantAssert);
 286         }
 287         updateValidPosFlag();
 288 }
 289
 290 // *********************************************************************************************************
 291 void CDisplayerVisual::updateValidPosFlag()
 292 {
 293         //H_AUTO(R2_CDisplayerVisual_updateValidPosFlag)
 294         // if I'm not a compound object, update my 'BadPos' flag
 295         if (!isCompound())
 296         {
 297                 // If I'm outside of current map then don't display the flag
 298                 CScenarioEntryPoints::CCompleteIsland *islandDesc = getEditor().getIslandCollision().getCurrIslandDesc();
 299                 if (islandDesc)
 300                 {
 301                         if ((sint32) _WorldPos.x < islandDesc->XMin ||
 302                                 (sint32) _WorldPos.x > islandDesc->XMax ||
 303                                 (sint32) _WorldPos.y < islandDesc->YMin ||
 304                                 (sint32) _WorldPos.y > islandDesc->YMax)
 305                         {
 306                                 setDisplayFlag(FlagBadPos, false);
 307                                 return;
 308                         }
 309                 }
 310                 setDisplayFlag(FlagBadPos, !getEditor().getIslandCollision().isValidPos(NLMISC::CVector(_WorldPos)));
 311         }
 312 }
 313
 314 // *********************************************************************************************************
 315 void CDisplayerVisual::updateWorldPosRecurse()
 316 {
 317         //H_AUTO(R2_CDisplayerVisual_updateWorldPosRecurse)
 318         struct CWorldPosUpdater : public IInstanceVisitor
 319         {
 320                 virtual void visit(CInstance &inst)
 321                 {
 322                         if (inst.getDisplayerVisual())
 323                         {
 324                                 inst.getDisplayerVisual()->updateWorldPos();
 325                         }
 326                 }
 327         };
 328         nlassert(getDisplayedInstance());
 329         CWorldPosUpdater worldPosUpdater;
 330         getDisplayedInstance()->visit(worldPosUpdater);
 331 }
 332
 333 // *********************************************************************************************************
 334 void CDisplayerVisual::onPostCreate()
 335 {
 336         //H_AUTO(R2_CDisplayerVisual_onPostCreate)
 337         _LastParentOk = false;
 338         updateLocalPos();
 339         updateWorldPos(); // do not recurse here because sons pos have not been initialized yet
 340         //updateDisplayMode();
 341         if (isActiveInCurrentAct())
 342         {
 343                 if (!getActive())
 344                 {
 345                         setActive(true);
 346                 }
 347         }
 348 }
 349
 350 // *********************************************************************************************************
 351 void CDisplayerVisual::onErase()
 352 {
 353         //H_AUTO(R2_CDisplayerVisual_onErase)
 354         if (getActive())
 355         {
 356                 setActive(false);
 357         }
 358 }
 359
 360 // *********************************************************************************************************
 361 void CDisplayerVisual::onPreActChanged()
 362 {
 363         //H_AUTO(R2_CDisplayerVisual_onPreActChanged)
 364         updatePos();
 365         if (!isActiveInCurrentAct())
 366         {
 367                 if (getActive())
 368                 {
 369                         setActive(false);
 370                 }
 371         }
 372 }
 373
 374 // *********************************************************************************************************
 375 void CDisplayerVisual::onActChanged()
 376 {
 377         //H_AUTO(R2_CDisplayerVisual_onActChanged)
 378         updatePos();
 379         if (isActiveInCurrentAct())
 380         {
 381                 if (!getActive())
 382                 {
 383                         setActive(true);
 384                 }
 385         }
 386 }
 387
 388 // *********************************************************************************************************
 389 void CDisplayerVisual::onContinentChanged()
 390 {
 391         //H_AUTO(R2_CDisplayerVisual_onContinentChanged)
 392         if (getActive())
 393         {
 394                 setActive(false);
 395                 setActive(true); // force a refresh of collision (EntitiesManager::changeContinent updates the primitive, but broken for an unknown reason ...)
 396         }
 397 }
 398
 399
 400 // *********************************************************************************************************
 401 bool CDisplayerVisual::isActiveInCurrentAct() const
 402 {
 403         //H_AUTO(R2_CDisplayerVisual_isActiveInCurrentAct)
 404         // parent act should be the base act (always exists), or the selected act
 405         CInstance *parentAct = getDisplayedInstance()->getParentAct();
 406         if (parentAct == getEditor().getBaseAct() || parentAct == getEditor().getCurrentAct())
 407         {
 408                 return true;
 409         }
 410         return false;
 411 }
 412
 413 // *********************************************************************************************************
 414 void CDisplayerVisual::onPostRender()
 415 {
 416         //H_AUTO(R2_CDisplayerVisual_onPostRender)
 417         if (!getActive()) return;
 418
 419         // if this entity is currently moving then don't display the 'stop' icon
 420         // (it is already drawn by the mouse cursor)
 421         if (getDisplayedInstance() == getEditor().getSelectedInstance()
 422                 && dynamic_cast<CToolSelectMove *>(getEditor().getCurrentTool()))
 423         {
 424                 if (_IconInScene)
 425                 {
 426                         _IconInScene->setActive(false);
 427                 }
 428         }
 429         else
 430         {
 431                 if (getDisplayFlag(FlagBadPos))
 432                 {
 433                         if (!_IconInScene && !_IconInSceneCreationFailed)
 434                         {
 435                                 CInterfaceManager *pIM = CInterfaceManager::getInstance();
 436                                 const char *iconTemplateName = "r2ed_bad_pos_icon";
 437                                 // if the in scene 'stop' window wasn't created, then create it now
 438                                 CInterfaceGroup *group = CWidgetManager::getInstance()->getParser()->createGroupInstance (iconTemplateName , "ui:interface", NULL, 0);
 439                                 if (group)
 440                                 {
 441                                         _IconInScene = dynamic_cast<CGroupInScene *>(group);
 442                                         if (!_IconInScene)
 443                                         {
 444                                                 nlwarning("Template %s has bad type : should be a derived group from CGroupInScene", iconTemplateName);
 445                                                 delete group;
 446                                                 _IconInSceneCreationFailed = true;
 447                                         }
 448                                         else
 449                                         {
 450                                                 // Link to the interface
 451                                                 CWidgetManager::getInstance()->addWindowToMasterGroup("ui:interface", group);
 452                                                 CInterfaceGroup *pRoot = dynamic_cast<CInterfaceGroup*>(CWidgetManager::getInstance()->getElementFromId("ui:interface"));
 453                                                 group->setParent(pRoot);
 454                                                 if (pRoot)
 455                                                         pRoot->addGroup (group);
 456                                         }
 457                                 }
 458                                 else
 459                                 {
 460                                         _IconInSceneCreationFailed = true;
 461                                 }
 462                         }
 463                         if (_IconInScene)
 464                         {
 465                                 _IconInScene->setActive(true);
 466                                 // tmp set a position above head
 467                                 evalIconInScenePos(_IconInScene->Position);
 468                         }
 469                 }
 470                 else
 471                 {
 472                         if (_IconInScene)
 473                         {
 474                                 _IconInScene->setActive(false);
 475                         }
 476                 }
 477         }
 478 }
 479
 480 // *********************************************************************************************************
 481 void CDisplayerVisual::evalIconInScenePos(NLMISC::CVector &dest) const
 482 {
 483         //H_AUTO(R2_CDisplayerVisual_evalIconInScenePos)
 484         NLMISC::CAABBox selectBox = getSelectBox();
 485         float radius = std::max(selectBox.getHalfSize().x, selectBox.getHalfSize().y);
 486         // use middle front of bbox for icon pos
 487         NLMISC::CVector result = getWorldPos().asVector() - radius * MainCam.getMatrix().getJ() + selectBox.getHalfSize().z * CVector::K;
 488         static volatile bool wantAssert = true;
 489         if (!isValidDouble(result.x) || !isValidDouble(result.y) ||!isValidDouble(result.z))
 490         {
 491                 nlassert(!wantAssert);
 492                 return;
 493         }
 494         dest = result;
 495 }
 496
 497
 498 // *********************************************************************************************************
 499 bool CDisplayerVisual::evalEnterPoint(const NLMISC::CVector &/* startPoint */,  NLMISC::CVector &result)
 500 {
 501         //H_AUTO(R2_CDisplayerVisual_evalEnterPoint)
 502         result = evalLinkPoint(false);
 503         return true;
 504 }
 505
 506 // *********************************************************************************************************
 507 NLMISC::CVector CDisplayerVisual::evalExitPoint()
 508 {
 509         //H_AUTO(R2_NLMISC_CVector )
 510         return evalLinkPoint(false);
 511 }
 512
 513 // *********************************************************************************************************
 514 void CDisplayerVisual::getSonsWorldPos2f(std::vector<NLMISC::CVector2f> &result)
 515 {
 516         //H_AUTO(R2_CDisplayerVisual_getSonsWorldPos2f)
 517         result.clear();
 518 }
 519
 520 // *********************************************************************************************************
 521 void CDisplayerVisual::getSons(std::vector<CDisplayerVisual *> &sons) const
 522 {
 523         //H_AUTO(R2_CDisplayerVisual_getSons)
 524         sons.clear(); // no sons by default
 525 }
 526
 527 // *********************************************************************************************************
 528 void CDisplayerVisual::setRotateInProgress(bool rotateInProgress)
 529 {
 530         //H_AUTO(R2_CDisplayerVisual_setRotateInProgress)
 531         _RotateInProgress = rotateInProgress;
 532 }
 533
 534 // *********************************************************************************************************
 535 void CDisplayerVisual::setMoveInProgress(bool moveInProgress)
 536 {
 537         //H_AUTO(R2_CDisplayerVisual_setMoveInProgress)
 538         _MoveInProgress = moveInProgress;
 539 }
 540
 541 // *********************************************************************************************************
 542 bool CDisplayerVisual::testNeedZEval()
 543 {
 544         //H_AUTO(R2_CDisplayerVisual_testNeedZEval)
 545
 546         if (SkipFrame == 0) // don't update just after a tp because landscape hasn't been updated yet ...
 547         {
 548                 float newCamDist = (MainCam.getMatrix().getPos() - _WorldPos).norm();
 549                 if (fabsf(newCamDist - _LastCamDist) >= 5.f)
 550                 {
 551                         _LastCamDist = newCamDist;
 552                         updateValidPosFlag();
 553                         return true;
 554                 }
 555         }
 556         else
 557         {
 558                 _LastCamDist = -100.f;
 559                 //nlwarning("Waiting skip frame : %d", (int) SkipFrame);
 560         }
 561         return false;
 562 }
 563
 564 // *********************************************************************************************************
 565 bool CDisplayerVisual::isSelectable() const
 566 {
 567         //H_AUTO(R2_CDisplayerVisual_isSelectable)
 568         static volatile bool bypass = false;
 569         if (bypass) return false;
 570         TDisplayMode dm = getActualDisplayMode();
 571         return getDisplayedInstance()->getSelectableFromRoot() && (dm == DisplayModeVisible || dm == DisplayModeLocked);
 572 }
 573
 574 // *********************************************************************************************************
 575 CDisplayerVisual::TDisplayMode CDisplayerVisual::getActualDisplayMode() const
 576 {
 577         //H_AUTO(R2_CDisplayerVisual_getActualDisplayMode)
 578         static volatile bool bypass = false;
 579         if (bypass)
 580         {
 581                 return CDisplayerVisual::DisplayModeVisible;
 582         }
 583
 584         TDisplayMode dm;
 585         const CDisplayerVisual *parent = getParent();
 586         if (_InheritDisplayMode && parent)
 587         {
 588                 TDisplayMode parentDM = parent->getActualDisplayMode();
 589                 dm = parentDM == DisplayModeVisible ? _DisplayMode : parentDM;
 590         }
 591         else
 592         {
 593                 dm= _DisplayMode;
 594         }
 595
 596         static volatile bool bypass2 = false;
 597         if (bypass2)
 598         {
 599                 return CDisplayerVisual::DisplayModeVisible;
 600         }
 601
 602         if (!getDisplayedInstance()->getSelectableFromRoot() && dm != DisplayModeHidden)
 603         {
 604                 dm = DisplayModeFrozen;
 605         }
 606
 607         static volatile bool bypass3 = false;
 608         if (bypass3)
 609         {
 610                 return CDisplayerVisual::DisplayModeVisible;
 611         }
 612
 613         // If it is not an animation but a scenario started from ring access do not display things
 614         if ( CEditor::getIsStartingScenario() )
 615         {
 616                 return DisplayModeHidden;
 617         }
 618         return dm;
 619 }
 620
 621 // *********************************************************************************************************
 622 CRGBA CDisplayerVisual::getDisplayModeColorInScene() const
 623 {
 624         //H_AUTO(R2_CDisplayerVisual_getDisplayModeColorInScene)
 625         switch(getActualDisplayMode())
 626         {
 627                 case DisplayModeVisible: return CV_UnselectedInstanceColor.get();
 628                 case DisplayModeFrozen: return CV_FrozenInstanceColor.get();
 629                 case DisplayModeLocked: return CV_LockedInstanceColor.get();
 630                 case DisplayModeArray: return CV_ArrayInstanceColor.get();
 631                 default: return CRGBA(0, 0, 0 ,0);
 632         }
 633 }
 634
 635 // *********************************************************************************************************
 636 CRGBA CDisplayerVisual::getDisplayModeColorInMap() const
 637 {
 638         //H_AUTO(R2_CDisplayerVisual_getDisplayModeColorInMap)
 639         switch(getActualDisplayMode())
 640         {
 641                 case DisplayModeVisible: return CRGBA::White;
 642                 case DisplayModeFrozen: return CV_MapEntityFrozenColor.get();
 643                 case DisplayModeLocked: return CV_MapEntityLockedColor.get();
 644                 case DisplayModeArray: return CV_ArrayInstanceColor.get();
 645                 default: return CRGBA(0, 0, 0 ,0);
 646         }
 647 }
 648
 649 // *********************************************************************************************************
 650 bool CDisplayerVisual::init(const CLuaObject &parameters)
 651 {
 652         //H_AUTO(R2_CDisplayerVisual_init)
 653         if (parameters["InheritDisplayMode"].isBoolean())
 654         {
 655                 _InheritDisplayMode = parameters["InheritDisplayMode"].toBoolean();
 656         }
 657         return CDisplayerBase::init(parameters);
 658 }
 659
 660 // *********************************************************************************************************
 661 void CDisplayerVisual::setDisplayMode(sint32 mode)
 662 {
 663         //H_AUTO(R2_CDisplayerVisual_setDisplayMode)
 664         if (mode == _DisplayMode) return;
 665         if (mode < 0 || mode >= DisplayModeCount)
 666         {
 667                 nlwarning("Trying to set invalid display mode : %d", (int) mode);
 668                 return;
 669         }
 670         _DisplayMode = (TDisplayMode) mode;
 671         uint numSons = getNumSons();
 672         for(uint k = 0; k < numSons; ++k)
 673         {
 674                 CDisplayerVisual *dv = getSon(k);
 675                 if (dv)
 676                 {
 677                         dv->onParentDisplayModeChanged();
 678                 }
 679         }
 680 }
 681
 682
 683 } // R2