ryzom/client/src/r2/displayer_visual_group.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 // Copyright (C) 2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   7 //
   8 // This program is free software: you can redistribute it and/or modify
   9 // it under the terms of the GNU Affero General Public License as
  10 // published by the Free Software Foundation, either version 3 of the
  11 // License, or (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU Affero General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU Affero General Public License
  19 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 #include "stdpch.h"
  22 //
  23 #include "nel/misc/line.h"
  24 #include "nel/3d/u_bone.h"
  25 //
  26 #include "nel/3d/u_landscape.h"
  27
  28 #include "nel/3d/zone.h"
  29 //
  30 #include "displayer_visual_group.h"
  31 #include "r2_config.h"
  32 #include "instance.h"
  33 #include "editor.h"
  34 #include "tool_draw_prim.h"
  35 //
  36 #include "../entity_cl.h"
  37 #include "../global.h"
  38 #include "../misc.h"
  39 #include "../landscape_poly_drawer.h"
  40 #include "nel/gui/ctrl_polygon.h"
  41 #include "nel/gui/ctrl_quad.h"
  42 #include "../time_client.h"
  43 //
  44
  45 #ifdef DEBUG_NEW
  46 #define new DEBUG_NEW
  47 #endif
  48
  49 class CGroupMap;
  50
  51 using namespace R2;
  52 using namespace std;
  53 using namespace NLMISC;
  54 using namespace NL3D;
  55
  56 extern ULandscape       *Landscape;
  57
  58 namespace R2
  59 {
  60
  61 // create a special selectable polygon
  62 class CCtrlPolygonSelectable : public CCtrlPolygon, public IDisplayerUIHandle
  63 {
  64 public:
  65         CCtrlPolygonSelectable( CViewBase::TCtorParam &param, CInstance &instance) : CCtrlPolygon(param), Instance(instance) {}
  66         // from IDisplayerUIHandle
  67         virtual CInstance &getDisplayedInstance() { return Instance; }
  68         // from IDisplayerUIHandle
  69         virtual bool contains(sint32 mouseXInWindow, sint32 mouseYInWindow) const
  70         {
  71                 if (!_Parent) return false;
  72
  73                 // relies on parent class CViewPolygon::contains
  74                 return CCtrlPolygon::contains(CVector2f(mouseXInWindow + 0.5f, mouseYInWindow + 0.5f));
  75         }
  76         // tooltip
  77         virtual void            getContextHelp(std::string &help) const
  78         {
  79                 help = Instance.getDisplayName().toUtf8();
  80                 if (help == NLMISC::CI18N::get("uiR2EDNoName"))
  81                         help.clear();
  82         }
  83         bool                            emptyContextHelp() const { return true; }
  84         bool                            wantInstantContextHelp() const { return true; }
  85         // from CCtrlBase
  86         virtual bool            preciseHitTest(sint32 x, sint32 y) const
  87         {
  88                 if (!_Parent) return false;
  89                 sint32 winX, winY;
  90                 _Parent->getCorner(winX, winY, _ParentPosRef);
  91                 return contains(x - winX, y - winY);
  92         }
  93 public:
  94         CInstance &Instance;
  95 protected:
  96         // TMP TMP until matrix precision is solved
  97         // from CCtrlPolygon
  98         void computeScaledVertex(NLMISC::CVector2f &dest, const NLMISC::CVector2f &src)
  99         {
 100                 CGroupMap *gm = CTool::getWorldMap();
 101                 if (!gm) dest = CVector::Null;
 102                 else gm->worldToWindow(dest, src);
 103         }
 104 };
 105
 106 // create a special selectable polygon
 107 class CCtrlQuadSelectable : public CCtrlQuad, public IDisplayerUIHandle
 108 {
 109 public:
 110         CCtrlQuadSelectable( CViewBase::TCtorParam &param, CInstance &instance, uint edgeIndex) : CCtrlQuad(param), Instance(instance), EdgeIndex(edgeIndex) {}
 111         // from IDisplayerUIHandle
 112         virtual CInstance &getDisplayedInstance() { return Instance; }
 113         // from IDisplayerUIHandle
 114         virtual bool isEdge() const { return true; }
 115         // from IDisplayerUIHandle
 116         virtual uint getEdgeIndex() const { return EdgeIndex; }
 117         // from IDisplayerUIHandle
 118         virtual bool contains(sint32 mouseXInWindow, sint32 mouseYInWindow) const
 119         {
 120                 if (!_Parent) return false;
 121
 122                 // relies on parent class CViewPolygon::contains
 123                 return CCtrlQuad::contains(CVector2f(mouseXInWindow + 0.5f, mouseYInWindow + 0.5f));
 124         }
 125         // tooltip
 126         virtual void            getContextHelp(std::string &help) const
 127         {
 128                 help = Instance.getDisplayName().toUtf8();
 129                 if (help == NLMISC::CI18N::get("uiR2EDNoName"))
 130                         help.clear();
 131         }
 132         bool                            emptyContextHelp() const { return true; }
 133         bool                            wantInstantContextHelp() const { return true; }
 134         // from CCtrlBase
 135         virtual bool            preciseHitTest(sint32 x, sint32 y) const
 136         {
 137                 if (!_Parent) return false;
 138                 sint32 winX, winY;
 139                 _Parent->getCorner(winX, winY, _ParentPosRef);
 140                 return contains(x - winX, y - winY);
 141         }
 142         virtual bool            handleEvent (const NLGUI::CEventDescriptor &/* event */)
 143         {
 144                 return false;
 145         }
 146 public:
 147         CInstance &Instance;
 148         uint      EdgeIndex;
 149 };
 150
 151
 152
 153 // *********************************************************************************************************
 154 CDisplayerVisualGroup::CDisplayerVisualGroup()
 155 {
 156         _ArrayName = "Components";
 157         _DrawnThisFrame = false;
 158         _TimeOver = 0;
 159         _CurrPrimValid = true;
 160         touch();
 161         _Active = false;
 162         _CurrPrimInaccessible = false;
 163         _ContextualVisibilityActive = false;
 164         _ContextualVisibilityDate = -1;
 165         _VisibleLastFrame = false;
 166 }
 167
 168 // *********************************************************************************************************
 169 void CDisplayerVisualGroup::touch()
 170 {
 171         //H_AUTO(R2_CDisplayerVisualGroup_touch)
 172         _PrimTouched = true;
 173         _InstanceListTouched = true;
 174         _AccessibilityTouched = true;
 175 }
 176
 177 // *********************************************************************************************************
 178 void CDisplayerVisualGroup::setDisplayedInstance(CInstance *instance)
 179 {
 180         //H_AUTO(R2_CDisplayerVisualGroup_setDisplayedInstance)
 181         CDisplayerVisual::setDisplayedInstance(instance);
 182         _Prim.DisplayedInstance = instance;
 183 }
 184
 185 // *********************************************************************************************************
 186 CCtrlPolygon *CDisplayerVisualGroup::CSelectablePrimRender::newCtrlPolygon() const
 187 {
 188         //H_AUTO(R2_CDisplayerVisualGroup_CSelectablePrimRender)
 189         nlassert(DisplayedInstance);
 190         CViewBase::TCtorParam param;
 191         CCtrlPolygonSelectable *result = new CCtrlPolygonSelectable( param, *DisplayedInstance);
 192         result->setId(DisplayedInstance->getId());
 193         result->setToolTipParent(CCtrlBase::TTMouse);
 194         result->setToolTipParentPosRef(Hotspot_BR);
 195         result->setToolTipPosRef(Hotspot_TL);
 196         return result;
 197 }
 198
 199 // *********************************************************************************************************
 200 CCtrlQuad *CDisplayerVisualGroup::CSelectablePrimRender::newCtrlQuad(uint edgeIndex) const
 201 {
 202         //H_AUTO(R2_CDisplayerVisualGroup_CSelectablePrimRender)
 203         nlassert(DisplayedInstance);
 204         CViewBase::TCtorParam param;
 205         CCtrlQuadSelectable *result = new CCtrlQuadSelectable( param, *DisplayedInstance, edgeIndex);
 206         result->setToolTipParent(CCtrlBase::TTMouse);
 207         result->setToolTipParentPosRef(Hotspot_BR);
 208         result->setToolTipPosRef(Hotspot_TL);
 209         return result;
 210 }
 211
 212 // *********************************************************************************************************
 213 bool CDisplayerVisualGroup::init(const CLuaObject &parameters)
 214 {
 215         //H_AUTO(R2_CDisplayerVisualGroup_init)
 216         CDisplayerVisual::init(parameters);
 217         if (parameters["Look"].isTable())
 218         {
 219                 _PrimLook.init(parameters["Look"]);
 220         }
 221         if (parameters["InvalidLook"].isTable())
 222         {
 223                 _PrimLookInvalid.init(parameters["InvalidLook"]);
 224         }
 225         else
 226         {
 227                 _PrimLookInvalid = _PrimLook;
 228         }
 229         _Prim.setLook(_PrimLook);
 230         if (parameters["ArrayName"].isString())
 231         {
 232                 _ArrayName = parameters["ArrayName"].toString();
 233         }
 234         // look for inaccessible parts (hardcoded for now)
 235         CPrimLook inaccessibleLook;
 236         inaccessibleLook.init(getEditor().getEnv()["PrimRender"]["RoadLookInaccessible"]);
 237         inaccessibleLook.Shape = _PrimLook.Shape;
 238         _InaccessiblePrim.setLook(inaccessibleLook);
 239
 240         // meshs
 241         //_Links.setShapeName(parameters["ShapeName"].toString());
 242         // decals
 243         return true;
 244 }
 245
 246 // *********************************************************************************************************
 247 CDisplayerVisualGroup::~CDisplayerVisualGroup()
 248 {
 249
 250 }
 251
 252
 253 // *********************************************************************************************************
 254 void CDisplayerVisualGroup::setActive(bool active)
 255 {
 256         //H_AUTO(R2_CDisplayerVisualGroup_setActive)
 257         if (active == _Active) return;
 258         CGroupMap *worldMap = CTool::getWorldMap();
 259         if (worldMap)
 260         {
 261                 if (active)
 262                 {
 263                         if (!_Prim.isAddedToWorldMap())
 264                         {
 265                                 worldMap->addDeco(&_Prim);
 266                         }
 267                 }
 268                 else
 269                 {
 270                         if (_Prim.isAddedToWorldMap())
 271                         {
 272                                 worldMap->removeDeco(&_Prim);
 273                         }
 274                         if (_InaccessiblePrim.isAddedToWorldMap())
 275                         {
 276                                 worldMap->removeDeco(&_InaccessiblePrim);
 277                         }
 278                 }
 279         }
 280         if (active)
 281         {
 282                 touch();
 283         }
 284         else
 285         {
 286                 _Prim.clear();
 287         }
 288         _Active = active;
 289 }
 290
 291 // *********************************************************************************************************
 292 bool CDisplayerVisualGroup::getActive() const
 293 {
 294         //H_AUTO(R2_CDisplayerVisualGroup_getActive)
 295         return _Active;
 296 }
 297
 298
 299 // *********************************************************************************************************
 300 void CDisplayerVisualGroup::onAttrModified(const std::string &attrName,  sint32 attrIndex)
 301 {
 302         //H_AUTO(R2_CDisplayerVisualGroup_onAttrModified)
 303         CDisplayerVisual::onAttrModified(attrName,  attrIndex);
 304         // necessary to handle this because there no event for 'element removed from table' for now ...
 305         if (attrName == _ArrayName)
 306         {
 307                 touch();
 308         }
 309         /*else if (attrName == "DisplayMode")
 310         {
 311                 touch();
 312                 updatePrimLook();
 313         }*/
 314 }
 315
 316 // *********************************************************************************************************
 317 void CDisplayerVisualGroup::setDisplayMode(sint32 mode)
 318 {
 319         //H_AUTO(R2_CDisplayerVisualGroup_setDisplayMode)
 320         CDisplayerVisual::setDisplayMode(mode);
 321         touch();
 322         updatePrimLook();
 323 }
 324
 325 // *********************************************************************************************************
 326 void CDisplayerVisualGroup::onParentDisplayModeChanged()
 327 {
 328         //H_AUTO(R2_CDisplayerVisualGroup_onParentDisplayModeChanged)
 329         touch();
 330         updatePrimLook();
 331 }
 332
 333 // *********************************************************************************************************
 334 void CDisplayerVisualGroup::updateWorldPos()
 335 {
 336         //H_AUTO(R2_CDisplayerVisualGroup_updateWorldPos)
 337         CDisplayerVisual::updateWorldPos();
 338         // must update position on next display
 339         _PrimTouched = true;
 340         _AccessibilityTouched = true;
 341 }
 342
 343 // *********************************************************************************************************
 344 bool CDisplayerVisualGroup::isInProjection(const NLMISC::CVector2f &pos) const
 345 {
 346         if (!_DrawnThisFrame) return false;
 347         if ((sint)_Prim.getLook().Shape == (sint)ClosedPolyLine)
 348         {
 349                 // poly test
 350                 if (_Poly2D.contains(pos, false)) return true;
 351         }
 352         // test intersection with all decals
 353         return _Prim.contains(pos);
 354 }
 355
 356 // *********************************************************************************************************
 357 bool CDisplayerVisualGroup::isInProjectionBorder(const NLMISC::CVector2f &pos) const
 358 {
 359         if (isOnEdge(pos) != -1)
 360         {
 361                 return true;
 362         }
 363         return false;
 364 }
 365
 366 // *********************************************************************************************************
 367 sint CDisplayerVisualGroup::isOnEdge(const NLMISC::CVector2f &pos) const
 368 {
 369         return _Prim.isOnEdge(pos);
 370 }
 371
 372 // *********************************************************************************************************
 373 uint CDisplayerVisualGroup::getFadeTimeInMS() const
 374 {
 375         return (uint) CV_RegionFadeTimeInMs.get();
 376 }
 377
 378
 379 // *********************************************************************************************************
 380 void CDisplayerVisualGroup::onPostRender()
 381 {
 382         if (!_Active ||!getActualVisibility()) return;
 383         updatePrimVertices();
 384         updateAccessibility();
 385 }
 386
 387 // *********************************************************************************************************
 388 bool CDisplayerVisualGroup::isAccessible()
 389 {
 390         updateAccessibility();
 391         return !_CurrPrimInaccessible;
 392 }
 393
 394 // *********************************************************************************************************
 395 void CDisplayerVisualGroup::updateAccessibility()
 396 {
 397         //H_AUTO(R2_CDisplayerVisualGroup_updateAccessibility)
 398         if (getEditor().getIslandCollision().getPackedIsland() != _LastIsland)
 399         {
 400                 _AccessibilityTouched = true;
 401
 402         }
 403         if (!_AccessibilityTouched) return;
 404         if (!_Active)
 405         {
 406                 // if not active, don't update the flag !!! This only is a display flag
 407                 // only npc group use the 'star' shape for now ...
 408                 _CurrPrimInaccessible = false;
 409                 _AccessibilityTouched = false;
 410                 return;
 411         }
 412         _LastIsland = getEditor().getIslandCollision().getPackedIsland();
 413         updatePrimVertices();
 414         uint numVerts = (uint)_Prim.getVertices().size();
 415         _CurrPrimInaccessible = false;
 416         // Old version : path should be accessible along the edges
 417         /*
 418         if (_Prim.getLook().Shape != CPrimLook::ClosedPolyLine) -- numVerts;
 419         for (uint k = 0; k < numVerts; ++k)
 420         {
 421                 if (!getEditor().getIslandCollision().isValidSegment(_Prim.getVertices()[k], _Prim.getVertices()[(k + 1) % _Prim.getVertices().size()]))
 422                 {
 423                         _CurrPrimInaccessible = true;
 424                         break;
 425                 }
 426         }
 427         */
 428         // New version : path should be accessible at vertices only
 429         for (uint k = 0; k < numVerts; ++k)
 430         {
 431                 if (!getEditor().getIslandCollision().isValidPos(_Prim.getVertices()[k]))
 432                 {
 433                         _CurrPrimInaccessible = true;
 434                         break;
 435                 }
 436         }
 437         CGroupMap *gm = CTool::getWorldMap();
 438         if (gm)
 439         {
 440                 // error: no more display of inaccessible pos
 441                 /*
 442                 if (_CurrPrimInaccessible)
 443                 {
 444                         _InaccessiblePrim.setVertices(_Prim.getVertices());
 445                         if (!_InaccessiblePrim.isAddedToWorldMap())
 446                         {
 447                                 gm->addDeco(&_InaccessiblePrim);
 448                         }
 449                 }
 450                 else
 451                 {
 452                         if (_InaccessiblePrim.isAddedToWorldMap())
 453                         {
 454                                 gm->removeDeco(&_InaccessiblePrim);
 455                         }
 456                 }
 457                 */
 458         }
 459         updatePrimLook();
 460         _AccessibilityTouched = false;
 461 }
 462
 463 // *********************************************************************************************************
 464 void CDisplayerVisualGroup::updatePrimVertices()
 465 {
 466         //H_AUTO(R2_CDisplayerVisualGroup_updatePrimVertices)
 467         if (!_Active) return;
 468         if (!_PrimTouched) return;
 469         updateInstanceList();
 470         //
 471         static std::vector<NLMISC::CVector> vertices;
 472         vertices.clear();
 473         _Poly2D.Vertices.clear();
 474         for(uint k = 0; k < _Instances.size(); ++k)
 475         {
 476                 if (_Instances[k])
 477                 {
 478                         vertices.push_back(_Instances[k]->evalLinkPoint(k == 0 && _Prim.getLook().Shape == CPrimLook::Star));
 479                         _Poly2D.Vertices.push_back(CVector(vertices.back().x,  vertices.back().y,  0.f));
 480                 }
 481                 else
 482                 {
 483                         nlwarning("_Instances[%d] == 0", k);
 484                 }
 485         }
 486
 487         if (_Prim.getLook().Shape == CPrimLook::ClosedPolyLine)
 488         {
 489                 updateBoundingBox();
 490         }
 491
 492         bool valid = true;
 493
 494         // test against the collision map : all traversed opsition must be valid else poly is invalid
 495         /*
 496         if (_PrimLook.Shape == CPrimLook::ClosedPolyLine)
 497         {
 498                 // test concave poly against map
 499
 500                 // test against water
 501                 #err
 502         }
 503         else
 504         {
 505                 // test polyline against map
 506                 R2::CScenarioEntryPoints::CCompleteIsland *island = getEditor().getIslandCollision().getCurrIslandDesc();
 507                 const NLMISC::CArray2D<sint16> &heightMap = getEditor().getIslandCollision().getHeightMap();
 508                 if (getEditor().getIslandCollision().getHeightMap())
 509                 {
 510
 511                 }
 512                 // test against water
 513                 #err
 514         }
 515         */
 516
 517         // if displayed on the map, set a first time to see if poly is invalid
 518         if (_PrimLook.Shape == CPrimLook::ClosedPolyLine)
 519         {
 520                 if (_Prim.getWorldMapPoly())
 521                 {
 522                         _Prim.getWorldMapPoly()->setVertices(vertices);
 523                         valid = _Prim.getWorldMapPoly()->isValid();
 524                 }
 525         }
 526         if (valid != _CurrPrimValid)
 527         {
 528                 _CurrPrimValid = valid;
 529                 updatePrimLook();
 530         }
 531         _Prim.setVertices(vertices);
 532         _PrimTouched = false;
 533 }
 534
 535 // *********************************************************************************************************
 536 void CDisplayerVisualGroup::updateBoundingBox()
 537 {
 538         //H_AUTO(R2_CDisplayerVisualGroup_updateBoundingBox)
 539         CLandscapePolyDrawer::computeBBoxFromPolygon(_Poly2D, _BBox);
 540 }
 541
 542 // *********************************************************************************************************
 543 void CDisplayerVisualGroup::updatePrimLook()
 544 {
 545         //H_AUTO(R2_CDisplayerVisualGroup_updatePrimLook)
 546         TDisplayMode displayMode = getActualDisplayMode();
 547         // if contextual visibility is enabled, then see if really visible
 548         if (displayMode != DisplayModeHidden && _ContextualVisibilityActive && getDisplayedInstance()->isKindOf("BasePrimitive"))
 549         {
 550                 if (!isContextuallyVisible())
 551                 {
 552                         displayMode = DisplayModeHidden;
 553                 }
 554         }
 555         //
 556         if (displayMode == DisplayModeHidden)
 557         {
 558                 _Prim.setActive(false);
 559                 _InaccessiblePrim.setActive(false);
 560                 return;
 561         }
 562
 563         _Prim.setActive(true);
 564         _InaccessiblePrim.setActive(true);
 565
 566         CPrimLook &look = (_CurrPrimValid && !_CurrPrimInaccessible) ? _PrimLook : _PrimLookInvalid;
 567         CRGBA oldEdgeWMCol = look.EdgeLook.WorldMapColor;
 568         CRGBA oldEdgeDecalCol = look.EdgeLook.DecalColor;
 569         CRGBA oldVertexWMCol = look.VertexLook.WorldMapColor;
 570         CRGBA oldVertexDecalCol = look.VertexLook.DecalColor;
 571         CRGBA oldFirstVertexWMCol = look.FirstVertexLook.WorldMapColor;
 572         CRGBA oldFirstVertexDecalCol = look.FirstVertexLook.DecalColor;
 573         CRGBA col;
 574         bool newCol = false;
 575         switch(displayMode)
 576         {
 577                 case DisplayModeFrozen:
 578                         col = getBlinkColor(CV_MapEntityFrozenColor.get());
 579                         newCol = true;
 580                 break;
 581                 case DisplayModeLocked:
 582                         col = getBlinkColor(CV_MapEntityLockedColor.get());
 583                         newCol = true;
 584                 break;
 585                 default:
 586                 break;
 587         }
 588         if (getDisplayFlag(FlagSelected) && !_CurrPrimInaccessible)
 589         {
 590                 // NB : don't want the highlight if not all parts are accessible
 591                 //      for readability
 592                 col = CV_MapEntitySelectColor.get();
 593                 newCol = true;
 594         }
 595         else if (getDisplayFlag(FlagHasFocus))
 596         {
 597                 col = CV_MapEntityHighlightColor.get();
 598                 newCol = true;
 599         }
 600         if (newCol)
 601         {
 602                 look.EdgeLook.WorldMapColor = col;
 603                 look.EdgeLook.DecalColor = col;
 604                 look.VertexLook.WorldMapColor = col;
 605                 look.VertexLook.DecalColor = col;
 606                 look.FirstVertexLook.WorldMapColor = col;
 607                 look.FirstVertexLook.DecalColor = col;
 608         }
 609         _Prim.setLook(look);
 610         if (newCol)
 611         {
 612                 look.EdgeLook.WorldMapColor = oldEdgeWMCol;
 613                 look.EdgeLook.DecalColor = oldEdgeDecalCol;
 614                 look.VertexLook.WorldMapColor = oldVertexWMCol;
 615                 look.VertexLook.DecalColor = oldVertexDecalCol;
 616                 look.FirstVertexLook.WorldMapColor = oldFirstVertexWMCol;
 617                 look.FirstVertexLook.DecalColor = oldFirstVertexDecalCol;
 618         }
 619 }
 620
 621 // *********************************************************************************************************
 622 void CDisplayerVisualGroup::onFocus(bool focused)
 623 {
 624         //H_AUTO(R2_CDisplayerVisualGroup_onFocus)
 625         CDisplayerVisual::onFocus(focused);
 626         updatePrimLook();
 627 }
 628
 629 // *********************************************************************************************************
 630 void CDisplayerVisualGroup::onSelect(bool selected)
 631 {
 632         //H_AUTO(R2_CDisplayerVisualGroup_onSelect)
 633         CDisplayerVisual::onSelect(selected);
 634         updatePrimLook();
 635 }
 636
 637 // *********************************************************************************************************
 638 void CDisplayerVisualGroup::onPreRender()
 639 {
 640         //H_AUTO(R2_CDisplayerVisualGroup_onPreRender)
 641         _DrawnThisFrame = false;
 642         if (!_Active) return;
 643         // see if render is on for primitives (don't use a config var because may be dynamically changed)
 644         //if (!getEditor().getConfig()["PrimDisplayEnabled"].toBoolean()) return;
 645         _DrawnThisFrame = true;
 646         bool nowVisible = getActualVisibility();
 647         if (_VisibleLastFrame != nowVisible)
 648         {
 649                 touch();
 650                 updatePrimLook();
 651         }
 652         _VisibleLastFrame = nowVisible;
 653         if (!nowVisible) return;
 654         //
 655         updatePrimVertices();
 656         // progressive higlight
 657         if (!getDisplayFlag(FlagSelected))
 658         {
 659                 if (getDisplayFlag(FlagHasFocus))
 660                 {
 661                         _TimeOver += DT64;
 662                         if (_TimeOver > getFadeTimeInMS())
 663                         {
 664                                 _TimeOver = getFadeTimeInMS();
 665                         }
 666                 }
 667                 else
 668                 {
 669                         _TimeOver -= DT64;
 670                         if (_TimeOver < 0)
 671                         {
 672                                 _TimeOver = 0;
 673                         }
 674                 }
 675         }
 676         else
 677         {
 678                 _TimeOver = 0;
 679         }
 680         float selectionFactor = 0.f;
 681         if (_TimeOver != 0)
 682         {
 683                 uint fadeTime = getFadeTimeInMS();
 684                 if (fadeTime != 0)
 685                 {
 686                         selectionFactor = (float) _TimeOver / fadeTime;
 687                 }
 688         }
 689         else
 690         {
 691                 selectionFactor = getDisplayFlag(FlagHasFocus) ? 1.f : 0.f;
 692         }
 693         //
 694         if (_Prim.getLook().Shape == CPrimLook::ClosedPolyLine && _CurrPrimValid)
 695         {
 696                 CRGBA baseColor;
 697                 switch(getActualDisplayMode())
 698                 {
 699                         case DisplayModeVisible:
 700                                 baseColor = CV_UnselectedRegionColor.get();
 701                         break;
 702                         case DisplayModeFrozen:
 703                                 baseColor = CV_FrozenRegionColor.get();
 704                         break;
 705                         case DisplayModeLocked:
 706                                 baseColor = CV_LockedRegionColor.get();
 707                         break;
 708                         default:
 709                                 baseColor = CV_UnselectedRegionColor.get();
 710                         break;
 711                 }
 712                 CRGBA polyColor;
 713                 if (getDisplayFlag(FlagSelected))
 714                 {
 715                         polyColor = CV_SelectedRegionColor.get();
 716                 }
 717                 else
 718                 {
 719                         polyColor = getBlinkColor(blend(baseColor, CV_FocusedRegionColor.get(), selectionFactor));
 720                 }
 721                 _Prim.setWorldMapPolyColor(polyColor);
 722                 static volatile bool showPoly = true;
 723                 if (showPoly)
 724                 {
 725                         CLandscapePolyDrawer::getInstance().addPoly(_Poly2D,  polyColor, _BBox);
 726                 }
 727         }
 728         /*
 729         if (getDisplayFlag(FlagSelected))
 730         {
 731                 _Prim.setEmissive(getBlinkColor(CV_SelectedInstanceColor.get()));
 732         }
 733         else
 734         {
 735                 _Prim.setEmissive(getBlinkColor(blend(CV_UnselectedInstanceColor.get(), CV_FocusedInstanceColor.get(), selectionFactor)));
 736         }
 737         */
 738         //
 739         _Prim.addDecalsToRenderList();
 740
 741         if (_CurrPrimInaccessible)
 742         {
 743                 //  CHANGE: no more display for inaccessible parts
 744                 // update color blinkking for inaccessible
 745                 /*CToolDrawPrim::updateInaccessiblePrimRenderLook(_InaccessiblePrim);
 746                 _InaccessiblePrim.addDecalsToRenderList();
 747                 */
 748         }
 749 }
 750
 751
 752
 753 // *********************************************************************************************************
 754 void CDisplayerVisualGroup::updateInstanceList() const
 755 {
 756         //H_AUTO(R2_CDisplayerVisualGroup_updateInstanceList)
 757         if (!_InstanceListTouched) return;
 758         _InstanceListTouched = false;
 759         _Instances.clear();
 760         const CObject *sons = getProps().getAttr(_ArrayName);
 761         if (!sons) return;
 762         if (sons->getSize() == 0) return;
 763         _Instances.resize(sons->getSize());
 764         for(uint k = 0; k < sons->getSize(); ++k)
 765         {
 766                 CInstance *inst = getEditor().getInstanceFromObject(sons->getValueAtPos(k));
 767                 if (inst)
 768                 {
 769                         _Instances[k] = inst->getDisplayerVisual();
 770                 }
 771         }
 772 }
 773
 774 // *********************************************************************************************************
 775 NLMISC::CVector CDisplayerVisualGroup::evalLinkPoint(bool leader)
 776 {
 777         //H_AUTO(R2_NLMISC_CVector )
 778         updateInstanceList();
 779         if (!_Instances.empty())
 780         {
 781                 return _Instances[0]->evalLinkPoint(leader);
 782         }
 783         else
 784         {
 785                 nlwarning("_Instances[0] == 0");
 786                 return CVector::Null;
 787         }
 788 }
 789
 790
 791 // *********************************************************************************************************
 792 NLMISC::CVector CDisplayerVisualGroup::evalExitPoint()
 793 {
 794         //H_AUTO(R2_NLMISC_CVector )
 795         updateInstanceList();
 796         if (!_Instances.empty())
 797         {
 798                 return _Instances.back()->evalLinkPoint();
 799         }
 800         else
 801         {
 802                 nlwarning("_Instances[0] == 0");
 803                 return CVector::Null;
 804         }
 805 }
 806
 807
 808 // *********************************************************************************************************
 809 bool CDisplayerVisualGroup::evalEnterPoint(const NLMISC::CVector &startPoint,  NLMISC::CVector &result)
 810 {
 811         //H_AUTO(R2_CDisplayerVisualGroup_evalEnterPoint)
 812         updateInstanceList();
 813         if (_Prim.getLook().Shape != CPrimLook::ClosedPolyLine)
 814         {
 815                 if (!_Instances.empty())
 816                 {
 817                         result = _Instances[0]->getWorldPos().asVector();
 818                         return true;
 819                 }
 820                 return false;
 821         }
 822         _Poly2D.Vertices.resize(_Instances.size());
 823         for(uint k = 0; k < _Instances.size(); ++k)
 824         {
 825                 _Poly2D.Vertices[k] = _Instances[k]->getWorldPos().asVector();
 826         }
 827         if (_Poly2D.contains(startPoint, false))
 828         {
 829                 return false;
 830         }
 831         float bestDist = FLT_MAX;
 832         for(uint k = 0; k < _Instances.size(); ++k)
 833         {
 834                 CVector v0 = _Instances[k]->getWorldPos().asVector();
 835                 CVector v1 = _Instances[(k + 1) % _Instances.size()]->getWorldPos().asVector();
 836                 CLine l(v0, v1);
 837                 CVector proj;
 838
 839                 float coord = (startPoint - v0) * ((v1 - v0).normed());
 840                 float dist;
 841                 if (coord >= 0 && coord < (v1 - v0).norm())
 842                 {
 843                         l.project(startPoint, proj);
 844                         dist = (proj - startPoint).norm();
 845                         if (dist < bestDist)
 846                         {
 847                                 bestDist = dist;
 848                                 result = proj;
 849                         }
 850                 }
 851
 852                 dist = (startPoint - v0).norm();
 853                 if (dist < bestDist)
 854                 {
 855                         bestDist = dist;
 856                         result = v0;
 857                 }
 858
 859         }
 860         return bestDist != FLT_MAX;
 861 }
 862
 863 // *********************************************************************************************************
 864 const NLMISC::CMatrix &CDisplayerVisualGroup::getInvertedMatrix() const
 865 {
 866         //H_AUTO(R2_NLMISC_CMatrix )
 867         return CMatrix::Identity; // all coordinates are in world ...
 868 }
 869
 870 // *********************************************************************************************************
 871 void CDisplayerVisualGroup::getSonsWorldPos2f(std::vector<NLMISC::CVector2f> &result)
 872 {
 873         //H_AUTO(R2_CDisplayerVisualGroup_getSonsWorldPos2f)
 874         updateInstanceList();
 875         result.clear();
 876         for(uint k = 0; k < _Instances.size(); ++k)
 877         {
 878                 result.push_back(_Instances[k]->getWorldPos2f());
 879         }
 880 }
 881
 882 // *********************************************************************************************************
 883 void CDisplayerVisualGroup::getSons(std::vector<CDisplayerVisual *> &sons) const
 884 {
 885         //H_AUTO(R2_CDisplayerVisualGroup_getSons)
 886         updateInstanceList();
 887         sons.clear();
 888         sons.insert(sons.begin(), _Instances.begin(), _Instances.end());
 889 }
 890
 891 // *********************************************************************************************************
 892 uint CDisplayerVisualGroup::getNumSons() const
 893 {
 894         //H_AUTO(R2_CDisplayerVisualGroup_getNumSons)
 895         updateInstanceList();
 896         return (uint)_Instances.size();
 897 }
 898
 899 // *********************************************************************************************************
 900 CDisplayerVisual *CDisplayerVisualGroup::getSon(uint index) const
 901 {
 902         //H_AUTO(R2_CDisplayerVisualGroup_getSon)
 903         updateInstanceList();
 904         nlassert(index < _Instances.size());
 905         return _Instances[index];
 906 }
 907
 908 // *********************************************************************************************************
 909 void CDisplayerVisualGroup::setActiveRecurse(bool active)
 910 {
 911         //H_AUTO(R2_CDisplayerVisualGroup_setActiveRecurse)
 912         setActive(active);
 913         updateInstanceList();
 914         for(uint k = 0; k < _Instances.size(); ++k)
 915         {
 916                 _Instances[k]->setActive(active);
 917         }
 918 }
 919
 920 // *********************************************************************************************************
 921 void CDisplayerVisualGroup::setContextualVisibilityActive(bool active)
 922 {
 923         //H_AUTO(R2_CDisplayerVisualGroup_setContextualVisibilityActive)
 924         _ContextualVisibilityActive = active;
 925 }
 926
 927
 928 // *********************************************************************************************************
 929 CDisplayerVisual::TDisplayMode CDisplayerVisualGroup::getActualDisplayMode() const
 930 {
 931         //H_AUTO(R2_CDisplayerVisualGroup_getActualDisplayMode)
 932         TDisplayMode dm = CDisplayerVisual::getActualDisplayMode();
 933         if (dm == DisplayModeHidden) return dm;
 934         if (!_ContextualVisibilityActive || const_cast<CDisplayerVisualGroup *>(this)->isContextuallyVisible()) return dm;
 935         return DisplayModeHidden;
 936 }
 937
 938
 939 // *********************************************************************************************************
 940 bool CDisplayerVisualGroup::isContextuallyVisible()
 941 {
 942         //H_AUTO(R2_CDisplayerVisualGroup_isContextuallyVisible)
 943         if (!_ContextualVisibilityActive) return true;
 944         const CInstance *selection = getEditor().getSelectedInstance();
 945         if (selection)
 946         {
 947                 if (this == selection->getDisplayerVisual()) return true;
 948                 if (selection->getDisplayerVisual() && selection->getDisplayerVisual()->getParent() == this) return true;
 949         }
 950         return _ContextualVisibilityDate == T1;
 951 }
 952
 953
 954
 955 } // R2