ryzom/client/src/interface_v3/group_map.h

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010-2018  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
  21
  22
  23 #ifndef CL_GROUP_MAP_CL
  24 #define CL_GROUP_MAP_CL
  25
  26 #include "nel/misc/vector_2f.h"
  27 #include "nel/misc/ucstring.h"
  28
  29 #include "../client_sheets/world_sheet.h"
  30
  31 #include "nel/gui/interface_group.h"
  32 #include "nel/gui/ctrl_button.h"
  33 #include "nel/gui/view_bitmap.h"
  34 #include "nel/gui/view_text.h"
  35 #include "animal_position_state.h"
  36 #include "../continent.h"
  37 //
  38
  39
  40 class CContinent;
  41
  42 namespace NLMISC
  43 {
  44         class CCDBNodeLeaf;
  45 }
  46
  47 namespace NLGUI
  48 {
  49         class CCtrlQuad;
  50 }
  51
  52 class CWorldSheet;
  53 struct SMap;
  54
  55 namespace NL3D
  56 {
  57         class UMaterial;
  58         class UDriver;
  59         class UTextureFile;
  60 }
  61
  62
  63 #define MISSIONS_DB_PATH "SERVER:MISSIONS"
  64 #define GROUP_MISSIONS_DB_PATH "SERVER:GROUP:MISSIONS"
  65 #define COMPASS_DB_PATH "SERVER:COMPASS"
  66 //
  67 const float RYZOM_MAP_MAX_SCALE = 8.f;
  68
  69
  70 class CLandMarkOptions
  71 {
  72 public:
  73         std::string                     LandMarkTexNormal;
  74         std::string                     LandMarkTexOver;
  75         std::string                     LandMarkTexPushed;
  76         NLMISC::CRGBA           ColorNormal;
  77         NLMISC::CRGBA           ColorOver;
  78         NLMISC::CRGBA           ColorPushed;
  79         std::string                     LandMarkMenu;
  80 public:
  81         CLandMarkOptions()
  82         {
  83                 ColorNormal = ColorOver = ColorPushed = NLMISC::CRGBA::White;
  84         }
  85 };
  86
  87 class CArkPoint
  88 {
  89 public:
  90         sint32                          x, y;
  91         std::string                     Texture;
  92         NLMISC::CRGBA           Color;
  93         std::string                     Title;
  94         std::string                     LeftClickAction;
  95         std::string                     LeftClickParam;
  96         std::string                     RightClickAction;
  97         std::string                     RightClickParam;
  98
  99 public:
 100         CArkPoint()
 101         {
 102                 Color = NLMISC::CRGBA::White;
 103                 x = 0;
 104                 y = 0;
 105         }
 106 };
 107
 108 /**
 109  * Display of map and landmarks.
 110  *
 111  * There are several coordinate systems :
 112  *
 113  * - World coordinates : as usual
 114  * - Map coordinates : In the [0, 1] range. [0, 0] is the upper left of map, and [1, 1] is the lower right.
 115  *   the corners of the map in world coordinates are given by their zone names (in the continent sheet)
 116  * - Screen coordinates :  in pixels
 117  * - Window coordinates : the same as screen coordinate, but relative to that CInterfaceGroup
 118  *
 119  * \author Nicolas Vizerie
 120  * \author Nevrax France
 121  * \date 2003
 122  */
 123
 124 class CGroupMap : public CInterfaceGroup
 125 {
 126 public:
 127
 128         // external element to be displayed on the map
 129         struct IDeco
 130         {
 131                 /** called when the element is added to the map. If the deco is an interface element, it could
 132                   * add itself to this group child
 133                   */
 134                 virtual void onAdd(CGroupMap &/* owner */) {}
 135                 virtual void onRemove(CGroupMap &/* owner */) {}
 136                 virtual void onPreRender(CGroupMap &/* owner */) {}
 137                 /** Called when the map has been scrolled or scaled. The deco should update its pos here
 138                   *
 139                   */
 140                 virtual void onUpdate(CGroupMap &/* owner */) {}
 141         };
 142
 143         REFLECT_EXPORT_START(CGroupMap, CInterfaceGroup)
 144                 REFLECT_STRING("continent", getContinentName, dummySet);
 145                 REFLECT_STRING("texture", getMapTexture, dummySet);
 146                 REFLECT_LUA_METHOD("isIsland", luaIsIsland);
 147                 REFLECT_LUA_METHOD("reload", luaReload);
 148         REFLECT_EXPORT_END
 149
 150         int luaReload(CLuaState &ls);
 151         int luaIsIsland(CLuaState &ls);
 152
 153 public:
 154         CGroupMap(const TCtorParam &param);
 155         virtual ~CGroupMap();
 156         // Add a decoration to the map. The map will call the 'onAdd' method. When this object is destroyed, it will call the 'onRemove' method
 157         void addDeco(IDeco *deco);
 158         // Remove a decoration from the map. This will also call the 'onRemove' method. It is up to the owner to delete it.
 159         void removeDeco(IDeco *deco);
 160
 161         virtual void setActive (bool state);
 162         virtual void updateCoords();
 163         virtual void checkCoords();
 164         virtual void draw ();
 165         virtual bool handleEvent (const NLGUI::CEventDescriptor &event);
 166         virtual bool parse(xmlNodePtr cur, CInterfaceGroup * parentGroup);
 167         virtual bool getCtrlsUnder (sint32 x, sint32 y, sint32 clipX, sint32 clipY, sint32 clipW, sint32 clipH, std::vector<CCtrlBase*> &vICL);
 168
 169         // Name of the map as filled in the ryzom.world file
 170         void setMap(const std::string &mapName);
 171         void setMap(SMap *map);
 172
 173         // return current continent
 174         std::string getContinentName() const;
 175         // return currently displayed map texture
 176         std::string getMapTexture() const;
 177
 178         // reload current map texture
 179         void reload();
 180
 181         // pan the map of the given number of pixels
 182         void pan(sint32 dx, sint32 dy);
 183
 184         // center the map on the player
 185         void centerOnPlayer();
 186         // center current map on world coords (if not out of map bounds)
 187         void centerOnWorldPos(const NLMISC::CVector2f &worldPos);
 188
 189         void setPlayerPos(const NLMISC::CVector2f &p) { _PlayerPos = p; }
 190         NLMISC::CVector2f getPlayerPos() const { return _PlayerPos; }
 191         // test if player is currently panning the map
 192         bool isPanning() const { return _Panning; }
 193         /** Change the scale. It will be clipped to the max possible value
 194           * The center of the scale transformation must be given in the map coordinates.
 195           */
 196         void                            setScale(float newScale, const NLMISC::CVector2f &center);
 197         /** Change the scale. It will be clipped to the max possible value
 198           * The center of the scale is the center of current window
 199           */
 200         void                            setScale(float newScale);
 201         //
 202         float                           getScale() const { return _UserScale; }
 203         /// add a user landmark (returns a pointer on its button).Coordinate are in the current map (not world coordinates)
 204         CCtrlButton                     *addUserLandMark(const NLMISC::CVector2f &pos, const ucstring &title, const CUserLandMark::EUserLandMarkType lmType);
 205         /// return current continent landmark by its index and type
 206         CCtrlButton*            getLandmarkCtrl(const std::string &lmType, uint lmIndex) const;
 207         // remove a user landmark from a pointer on its button
 208         void                            removeUserLandMark(CCtrlButton *button);
 209         // update a user landmark from a pointer on its button
 210         void                            updateUserLandMark(CCtrlButton *button, const ucstring &newName, const CUserLandMark::EUserLandMarkType lmType);
 211         // get a user landmark from a pointer on its button
 212         CUserLandMark                   getUserLandMark(CCtrlButton *button) const;
 213         // get pos on the map of the last right click (in map coords)
 214         NLMISC::CVector2f               getRightClickLastPos() const { return _RightClickLastPos; }
 215         // get number of user landmarks
 216         uint                            getNumUserLandMarks() const;
 217         // get the LandMarksOptions for a given landmark index
 218         CLandMarkOptions                getUserLandMarkOptions(uint32 lmindex) const;
 219         // target the given landmark
 220         void                            targetLandmark(CCtrlButton *lm);
 221         void                            targetLandmarkResult(uint32 index);
 222         // search matching landmark and target it. return true if landmark was targeted
 223         bool                            targetLandmarkByName(const ucstring &search, bool startsWith) const;
 224         // get the world position of a landmark or return vector Null if not found
 225         void                            getLandmarkPosition(const CCtrlButton *lm, NLMISC::CVector2f &worldPos);
 226
 227         //Remove and re-create UserLandMarks
 228         void removeUserLandMarks();
 229         void updateUserLandMarks();
 230         void addUserLandMark(const NLMISC::CVector2f &pos, const ucstring &title, NLMISC::CRGBA color);
 231         void addUserRespawnPoint(const NLMISC::CVector2f &pos);
 232         void delArkPoints();
 233
 234
 235         // set landmarks visibility based text query
 236         void setLandmarkFilter(const std::string &s);
 237
 238         // set the selection axis pos & visibility
 239         void                            setSelectionAxis(bool active, const NLMISC::CVector2f &worldPos = NLMISC::CVector2f::Null);
 240
 241         // convert a pos in world to a pos in the window, snapped to the best pixel (-> all elements jump to the next pixel at the same time when the map is panned,
 242         // avoiding annoying flickering)
 243         void worldToWindowSnapped(sint32 &px, sint32 &py, const NLMISC::CVector2f &src) const;
 244         void worldToWindow(NLMISC::CVector2f &dest, const NLMISC::CVector2f &src) const;
 245         void mapToWindowSnapped(sint32 &px, sint32 &py, const NLMISC::CVector2f &src) const;
 246         // convert a pos in world to a pos in the map (in the [0, 1] range)
 247         void worldToMap(NLMISC::CVector2f &dest, const NLMISC::CVector2f &src) const;
 248         // convert a pos in world to a pos in map (coords are in [0, 1] in the map)
 249         void mapToWorld(NLMISC::CVector2f &dest, const NLMISC::CVector2f &src) const;
 250         // convert a pos in window in a pos in screen
 251         void windowToScreen(sint32 &destX, sint32 &destY, sint32 srcX, sint32 srcY) const;
 252         // convert a pos in the map to a pos on screen
 253         void mapToScreen(sint32 &px, sint32 &py, const NLMISC::CVector2f &src) const;
 254         //
 255         // convert a pos in the map to a pos relative to the current window (int result)
 256         void mapToWindow(sint32 &px, sint32 &py, const NLMISC::CVector2f &src) const;
 257         void mapToWindow(NLMISC::CVector2f &dest, const NLMISC::CVector2f &src) const;
 258         // convert a pos on screen to a pos in map
 259         void screenToMap(NLMISC::CVector2f &dest, sint32 px, sint32 py) const;
 260         // convert a pos on window to a pos in map
 261         void windowToMap(NLMISC::CVector2f &dest, sint32 px, sint32 py) const;
 262         float getMeterPerPixel() const { return _MeterPerPixel; }
 263
 264         //
 265         const NLMISC::CVector2f &getVisibleWorldMin() const { return _VisibleWorldMin; }
 266         const NLMISC::CVector2f &getVisibleWorldMax() const { return _VisibleWorldMax; }
 267
 268         // compute pos of displayed map relative to this group (may be equal are smaller than this group extent
 269         // depending on the scale.
 270         void computeMapRectInsideGroup(sint32 &x, sint32 &y, sint32 &w, sint32 &h) const;
 271
 272
 273         // From CInterfaceElement : scale and offset must persist between virtual desktops
 274         virtual bool wantSerialConfig() const { return true; }
 275         // From CInterfaceElement
 276         virtual void serialConfig(NLMISC::IStream &f);
 277
 278
 279         // Server set all valid respawn points
 280         void addRespawnPoints(const CRespawnPointsMsg &rpm);
 281
 282         // add Ark landscape point
 283         void addArkPoint(const CArkPoint &point);
 284
 285         std::string getArkPowoMode() const { return _ArkPowoMode; }
 286         void setArkPowoMode(const std::string &mode)  { _ArkPowoMode = mode; }
 287         std::string getArkPowoMapMenu() const { return _ArkPowoMapMenu; }
 288         void setArkPowoMapMenu(const std::string &menu)  { _ArkPowoMapMenu = menu; }
 289
 290         bool isInDeathMode() { return _MapMode == MapMode_Death; }
 291
 292         sint32 getRespawnSelected() const;
 293         void setRespawnSelected(sint32 nSpawnPointIndex);
 294
 295         SMap *getCurMap() { return _CurMap; }
 296         SMap *getParentMap(SMap *map);
 297
 298         const NLMISC::CVector2f &getWorldOffset() const { return _WorldOffset; }
 299
 300
 301         bool isIsland() const { return _IsIsland; }
 302
 303         void updateClosestLandMarkMenu(const std::string &menu, const NLMISC::CVector2f &pos) const;
 304
 305 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 306 private:
 307                 // A non rectangular button to click on zone of the map
 308                 class CPolyButton : public CCtrlBase
 309                 {
 310                 public:
 311                         CPolyButton();
 312                         virtual bool handleEvent (const NLGUI::CEventDescriptor &event);
 313                         virtual void updateCoords();
 314                         virtual void draw () {}
 315                         void drawPolyButton();
 316                         bool build(const NLLIGO::CPrimZone &concavePoly, CGroupMap *pMap, const std::string &sID);
 317                         bool contains(const NLMISC::CVector2f &pos);
 318                 public:
 319                         NLLIGO::CPrimZone Zone;
 320                         NLLIGO::CPrimZone ZoneReal;
 321                         std::vector<NLMISC::CPolygon2D> Polys;          // Vertices in map pos
 322                         std::vector<NLMISC::CPolygon2D> PolysReal;      // Vertices in screen pos
 323                         CGroupMap *Map;
 324                         std::string ID;
 325                         static NL3D::UMaterial LineMat;
 326                 };
 327                 typedef std::vector<CPolyButton*> TPolyButtonVect;
 328                 // a button representing a location on the map
 329                 class CLandMarkButton : public CCtrlButton
 330                 {
 331                         public:
 332                                 NLMISC::CVector2f Pos;
 333                                 CContLandMark::TContLMType Type;
 334                                 bool                                       HandleEvents;
 335                                 bool                                       SearchMatch;
 336                         public:
 337                                 virtual bool handleEvent (const NLGUI::CEventDescriptor& event)
 338                                 {
 339                                         if (!HandleEvents) return false;
 340                                         return CCtrlButton::handleEvent(event);
 341                                 }
 342                                 virtual bool            isCapturable() const
 343                                 {
 344                                         return HandleEvents;
 345                                 }
 346                                 virtual bool    wantInstantContextHelp() const { return true; } // from CCtrlBase : avoid delay when the mouse is over
 347                                 CLandMarkButton(const TCtorParam &param)
 348                                         : CCtrlButton(param)
 349                                 {
 350                                         Type = CContLandMark::Unknown;
 351                                         Pos.set(0.f, 0.f);
 352                                         HandleEvents = true;
 353                                         SearchMatch = false;
 354                                 }
 355                 };
 356                 typedef std::vector<CLandMarkButton*> TLandMarkButtonVect;
 357
 358                 // Text in the map
 359                 class CLandMarkText : public CViewText
 360                 {
 361                         public:
 362                                 NLMISC::CVector2f Pos;
 363                                 CContLandMark::TContLMType Type;
 364                                 bool SearchMatch;
 365
 366                                 CLandMarkText(const TCtorParam &param)
 367                                         : CViewText(param)
 368                                 {
 369                                         Type = CContLandMark::Unknown;
 370                                         Pos.set(0.f, 0.f);
 371                                         SearchMatch = false;
 372                                 }
 373                 };
 374                 typedef std::vector<CLandMarkText*> TLandMarkTextVect;
 375
 376                 float getActualMaxScale() const;
 377 private:
 378
 379         ///////////////////////
 380         // MULTIMAP HANDLING //
 381         ///////////////////////
 382
 383                 // Logical information to display the map
 384                 CWorldSheet                     *_WorldSheet;
 385                 SMap                            *_CurMap;
 386                 CContinent                      *_CurContinent; // the last continent for which the map was displayed (can be NULL if world)
 387                 NLMISC::CVector2f       _MapMinCorner; // In world coordinates
 388                 NLMISC::CVector2f       _MapMaxCorner;
 389                 std::string                     _MapTexture; // currently displayed map texture
 390
 391                 bool                            _IsIsland;  // true if current map is an island (island bitmap need not to be raised to the next
 392                                                                           // power of 2
 393
 394                 TPolyButtonVect         _PolyButtons;
 395
 396         //////////////////////////////
 397         // MAP & PLAYER POS TEXTURE //
 398         //////////////////////////////
 399
 400                 std::string                     _PlayerPosTexName;
 401                 // min height of the window
 402                 sint32                          _MinH;
 403                 //sint32                        _MinW;
 404                 // offset of the map view (offset is in uv coords)
 405                 NLMISC::CVector2f       _Offset;
 406                 float                           _UserScale;                     // user wanted scale
 407                 float                           _Scale;                         // actual scale for drawing
 408                 float                           _ScaleMax;
 409                 float                           _ScaleMaxR2;
 410                 float                           _MeterPerPixel;
 411                 //
 412                 float                           _WorldToMapDeltaX;
 413                 float                           _WorldToMapDeltaY;
 414                 //
 415                 NLMISC::CVector2f   _VisibleWorldMin;
 416                 NLMISC::CVector2f   _VisibleWorldMax;
 417                 // continent map material
 418                 NL3D::UMaterial         _MapMaterial;
 419                 // continent map texture
 420                 NL3D::UTextureFile      *_MapTF;
 421                 // player pos map material
 422                 NL3D::UMaterial         _PlayerPosMaterial;
 423                 // player pos map texture
 424                 NL3D::UTextureFile      *_PlayerPosTF;
 425                 NL3D::UMaterial         _FrustumMaterial;
 426
 427                 // continent map dimensions
 428                 uint32                          _MapTexW;                       // map texture width in pixels
 429                 uint32                          _MapTexH;                       // map texture height in pixels
 430                 uint32                          _PlayerPosTexW;         // playerpos texture width in pixels
 431                 uint32                          _PlayerPosTexH;         // playerpos texture height in pixels
 432                 float                           _URatio;                        // == _MapTexW / nextPowerOf2(_MapTexW)
 433                 float                           _VRatio;                        // == _MapTexH / nextPowerOf2(_MapTexH)
 434                 bool                            _MapLoadFailure;        // load failure for the map
 435                 bool                            _PlayerPosLoadFailure; // load failure for the player pos sprite
 436
 437                 NLMISC::CVector2f       _PlayerPos;                     // player pos ranging from 0.f to 1.f in the map
 438                 NLMISC::CVector2f       _OldPlayerPos;          // old player pos in world
 439
 440                 // position of map relative to its parent. Maybe 0 unless the map is centred
 441                 sint32                          _MapX;
 442                 sint32                          _MapY;
 443                 sint32                          _MapW;
 444                 sint32                          _MapH;
 445
 446                 std::string                     _ArkPowoMode;
 447                 std::string                     _ArkPowoMapMenu;
 448                 NLMISC::CRGBA           _FrustumViewColor;
 449                 NLMISC::CRGBA           _FrustumViewColorOver;
 450                 float                           _FrustumOverBlendFactor;
 451                 uint                            _FrustumViewBlendTimeInMs;
 452
 453                 // selection axis
 454                 CViewBitmap                     *_SelectionAxisH;
 455                 CViewBitmap                     *_SelectionAxisV;
 456
 457
 458
 459         ////////////
 460         // EVENTS //
 461         ////////////
 462
 463                 NLMISC::CVector2f       _RightClickLastPos;
 464                 bool                            _Panning;                                       // does the user currently 'pan' the map ?
 465                 bool                            _HasMoved;
 466                 sint64                          _PanStartDateInMs;
 467                 sint64                          _DeltaTimeBeforePanInMs;
 468                 uint                            _DeltaPosBeforePan;
 469                 // Panning
 470                 sint32                          _StartXForPaning;                       // start pos for panning (in map)
 471                 sint32                          _StartYForPaning;
 472                 NLMISC::CVector2f       _StartWorldOffsetForPaning;     // World Offset Panning
 473                 NLMISC::CVector2f       _WorldOffset;
 474
 475         ///////////////
 476         // LANDMARKS //
 477         ///////////////
 478
 479                 // landmarks of continent
 480                 TLandMarkButtonVect     _ContinentLM;
 481                 TLandMarkTextVect       _ContinentText;
 482                 // landmarks from user
 483                 TLandMarkButtonVect     _UserLM;
 484                 // landmarks for mission (one for each db entry)
 485                 TLandMarkButtonVect     _MissionLM;
 486                 // landmark for target
 487                 CLandMarkButton         *_TargetLM;
 488                 // landmark for home (user flat)
 489                 CLandMarkButton         *_HomeLM;
 490                 // landmark for animals
 491                 TLandMarkButtonVect     _AnimalLM;
 492                 // landmark for teammates
 493                 TLandMarkButtonVect     _TeammateLM;
 494
 495                 //
 496                 CLandMarkOptions        _ContinentLMOptions;
 497                 CLandMarkOptions        _MissionLMOptions;
 498                 CLandMarkOptions        _UserLMOptions;
 499                 CLandMarkOptions    _TargetLMOptions;
 500                 CLandMarkOptions    _HomeLMOptions;
 501                 CLandMarkOptions    _AnimalLMOptions;
 502                 CLandMarkOptions    _AnimalStableLMOptions;
 503                 CLandMarkOptions    _AnimalDeadLMOptions;
 504                 CLandMarkOptions    _TeammateLMOptions;
 505
 506                 //
 507                 // last texts id for missions targets
 508                 std::vector<sint32> _MissionTargetTextIDs;
 509                 // have the texts been received for mission targets ?
 510                 std::vector<bool>       _MissionTargetTextReceived;
 511                 // ptr on db leaf for coordinates of special landmarks
 512                 NLMISC::CCDBNodeLeaf            *_TargetPos;
 513                 NLMISC::CCDBNodeLeaf            *_HomePos;
 514                 // Animals State for landMarks
 515                 std::vector<NLMISC::CSmartPtr<CAnimalPositionState> >   _AnimalPosStates;
 516                 // Teammate State for landMarks
 517                 std::vector<NLMISC::CSmartPtr<CTeammatePositionState> > _TeammatePosStates;
 518                 // Mission State for landMarks
 519                 std::vector<NLMISC::CSmartPtr<CNamedEntityPositionState> >      _MissionPosStates;
 520
 521                 // ui id  of compass for targetting
 522                 std::string             _CompassId;
 523
 524                 // user decorations
 525                 typedef std::set<IDeco *> TDecos;
 526                 TDecos _Decos;
 527
 528                 // filter keywords
 529                 std::vector<ucstring> _LandmarkFilter;
 530                 struct SMatchedLandmark
 531                 {
 532                         SMatchedLandmark(const NLMISC::CVector2f pos, const ucstring &title, CLandMarkOptions opts)
 533                                 : Pos(pos), Title(title), Options(opts)
 534                         {}
 535                         NLMISC::CVector2f Pos;
 536                         ucstring Title;
 537
 538                         CLandMarkOptions Options;
 539                 };
 540                 std::vector<SMatchedLandmark> _MatchedLandmarks;
 541
 542         //////////////////////
 543         // Respawn handling //
 544         // //////////////// //
 545
 546                 enum TMapMode
 547                 {
 548                         MapMode_Normal = 0,
 549                         MapMode_Death,
 550                         MapMode_SpawnSquad
 551                 };
 552
 553                 TMapMode                        _MapMode;
 554                 std::vector<CArkPoint> _ArkPoints;
 555                 CLandMarkOptions        _RespawnLMOptions;
 556                 // landmark for respawn
 557                 TLandMarkButtonVect     _RespawnLM;
 558                 sint32                          _RespawnSelected;
 559                 CViewBitmap                     *_RespawnSelectedBitmap;
 560                 std::string                     _RespawnButton;
 561                 // Positions are coming from server
 562                 std::vector<CRespawnPointsMsg::SRespawnPoint> _RespawnPos;
 563                 bool                    _RespawnPosReseted;
 564                 CCtrlQuad                       *_FrustumView; // frustum on map for R2 editor
 565
 566         // r2 islands
 567         std::vector<SMap>       _Islands;
 568
 569         // guard against recursive calls
 570         bool                            _LuaLoadMapEntered;
 571
 572 private:
 573         void loadPlayerPos();
 574         void loadMap();
 575         void unloadMap();
 576         //
 577         void updateContinentInfo();
 578         /** update a list of landmarks
 579           * This update their position on the map depending on offset and scale
 580           */
 581         void updateLandMarkList(TLandMarkButtonVect &lm);
 582         void updateLandMarkTextList(TLandMarkTextVect &lm);
 583         void updateMatchedLandmarks();
 584         //
 585         void removeLandMarks(TLandMarkButtonVect &lm);
 586         /** create landmarks from the continent (and remove previous ones)
 587           * this includes fixed and user landmarks
 588           */
 589         void createContinentLandMarks();
 590         void createLMWidgets(const std::vector<CContLandMark> &lms);
 591
 592         // add a landmark in a list
 593         void addLandMark(TLandMarkButtonVect &destList, const NLMISC::CVector2f &pos, const ucstring &title, const CLandMarkOptions &options);
 594         // Create a landmark button, but do not add it to this group
 595         CLandMarkButton *createLandMarkButton(const CLandMarkOptions &options);
 596         // Create a Ark landmark button, but do not add it to this group
 597         CLandMarkButton *createArkPointButton(const CArkPoint &point);
 598
 599         // update a landmark button
 600         void updateLandMarkButton(CLandMarkButton *lmb, const CLandMarkOptions &options);
 601
 602         // Test title against landmark filter
 603         bool filterLandmark(const ucstring &title) const;
 604         bool filterLandmark(const ucstring &title, const std::vector<ucstring> filter, bool startsWith = false) const;
 605
 606         // return closest landmark which matches (case insensitive) search string
 607         // center position must be in world coordindates
 608         CLandMarkButton* findClosestLandmark(const NLMISC::CVector2f &center, const ucstring &search, bool startsWith, const TLandMarkButtonVect &landmarks, float &closest) const;
 609         CLandMarkText* findClosestLandmark(const NLMISC::CVector2f &center, const ucstring &search, bool startsWith, const TLandMarkTextVect &landmarks, float &closest) const;
 610
 611         // update the scale depending on the window size and the user scale
 612         void updateScale();
 613
 614         // compute real scale from user scale (this takes in account the size of the window)
 615         float computeRealScaleFromUserScale(float userScale) const;
 616
 617         // compute the user scale needed to reach the given real scale on screen (this takes in account the size of the window)
 618         float computeUserScaleFromRealScale(float realScale) const;
 619
 620         // eval map offset from its parent depending on scale
 621         void evalMapOffset(float userScale, float &scale, sint32 &x, sint32 &y) const;
 622
 623         // compute _Offset from the _WorldOffset. Then clamp so that region outside the map can't be seen
 624         void computeOffsets(const NLMISC::CVector2f &centerPos);
 625         void computeOffsets();
 626
 627         void updatePlayerPos();
 628         // clamp offsets & change window size if necessary
 629         //void fitWindow();
 630         //
 631         void updateButtonPos(CLandMarkButton &dest) const;
 632         // Update a landmark position from position given from the db as two int32's (before they're divided by 1000)
 633         void updateLMPosFromDBPos(CLandMarkButton *dest, sint32 x, sint32 y);
 634         // compute uv rect for current map (not including cropping)
 635         void computeUVRect(float &minU, float &minV, float &maxU, float &maxV) const;
 636
 637         void updateSelectionAxisSize();
 638         CViewBitmap *newSelectionAxis(NLMISC::CRGBA color);
 639         void computeFrustumQuad(NLMISC::CQuad &fruQuad) const;
 640 };
 641
 642 #endif