ryzom/client/src/interface_v3/action_handler_debug.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) 2014  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 using namespace std;
  24 using namespace NLMISC;
  25 using namespace NL3D;
  26
  27 #include "nel/gui/action_handler.h"
  28 #include "../misc.h"
  29 #include "../prim_file.h"
  30 #include "../graph.h"
  31 #include "../motion/user_controls.h"
  32 #include "../ig_callback.h"
  33 #include "../movie_shooter.h"
  34 #include "../weather.h"
  35 #include "../weather_manager_client.h"
  36 #include "../continent_manager.h"
  37 #include "../user_entity.h"
  38 #include "../connection.h"
  39
  40 using namespace NLGUI;
  41
  42 ////////////
  43 // GLOBAL //
  44 ////////////
  45 extern bool                                     Render;
  46 extern bool                                     WantProfiling;                  // Do we want a CPU profile?
  47 extern bool                                     WantProfilingVBLock;                    // Do we want a VBLock profile?
  48 extern bool                                     PACSBorders;
  49 extern bool                                     ARKPACSBorders;
  50 extern bool                                     DebugClusters;
  51 extern bool                                     SoundBox;
  52 extern uint8                            ShowInfos;
  53 extern UDriver                          *Driver;
  54 extern CUserControls            UserControls;
  55 extern CIGCallback                      *IGCallbacks;
  56 extern CLandscapeIGManager      LandscapeIGManager;
  57 extern bool                                     MovieShooterSaving;
  58 extern bool                                     Filter3D[RYZOM_MAX_FILTER_3D];
  59 extern ULandscape                       *Landscape;
  60 extern EGSPD::CSeason::TSeason          ManualSeasonValue;
  61 extern CContinentManager        ContinentMngr;
  62 extern NL3D::UScene                     *Scene;
  63 extern UCamera                          MainCam;
  64 extern bool                 ForceTrueWeatherValue;
  65 extern bool                                     InitCloudScape;
  66 extern bool                                     DisplayWeatherFunction;
  67 extern bool                                     FreezeGraph;
  68 extern bool                                     MovieShooterReplay;
  69 extern bool                                     MovieShooterSave;
  70
  71 void    endMovieShooting();
  72
  73
  74 // ***************************************************************************
  75 class CAHDisplayInfos : public IActionHandler
  76 {
  77         void execute(CCtrlBase * /* pCaller */, const std::string &/* params */)
  78         {
  79                 // can only be used by devs and CSR or in local mode
  80 #if FINAL_VERSION
  81                 if( ClientCfg.Local || hasPrivilegeDEV() || hasPrivilegeSGM() || hasPrivilegeGM() || hasPrivilegeSG() || hasPrivilegeEM() || hasPrivilegeVG() )
  82 #endif
  83                 {
  84                         ShowInfos = (ShowInfos+1)%6;
  85
  86                         CGraph::Display = (ShowInfos != 0);
  87                 }
  88         }
  89 };
  90 // ***************************************************************************
  91 REGISTER_ACTION_HANDLER (CAHDisplayInfos, "display_infos");
  92
  93
  94 /**********************************************************************************************************
  95 *                                                                                                                                                                                                                 *
  96 *                                                                               move player handlers  actions                                                                     *
  97 *                                                                                                                                                                                                                 *
  98 ***********************************************************************************************************/
  99
 100 // ------------------------------------------------------------------------------------------------
 101 class CAHToggleARKPACSBorders : public IActionHandler
 102 {
 103         virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
 104         {
 105                 if (!getParam(Params, "on").empty())
 106                         ARKPACSBorders = true;
 107                 else if (!getParam(Params, "off").empty())
 108                         ARKPACSBorders = false;
 109                 else ARKPACSBorders = !ARKPACSBorders;
 110
 111         }
 112 };
 113 REGISTER_ACTION_HANDLER (CAHToggleARKPACSBorders, "ark_pacs_borders");
 114
 115 #if !FINAL_VERSION
 116 // ------------------------------------------------------------------------------------------------
 117 class CAHProfile : public IActionHandler
 118 {
 119         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 120         {
 121                 WantProfiling= true;
 122         }
 123 };
 124 REGISTER_ACTION_HANDLER (CAHProfile, "profile");
 125
 126 // ------------------------------------------------------------------------------------------------
 127 class CAHProfileVBLock : public IActionHandler
 128 {
 129         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 130         {
 131                 WantProfilingVBLock= true;
 132         }
 133 };
 134 REGISTER_ACTION_HANDLER (CAHProfileVBLock, "profile_vblock");
 135
 136 // ------------------------------------------------------------------------------------------------
 137 class CAHProfileFillRate : public IActionHandler
 138 {
 139         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 140         {
 141                 static  bool    minimized= false;
 142                 minimized= !minimized;
 143                 if(minimized)
 144                 {
 145                         CViewport       vp;
 146                         vp.init(0, 0, 0.1f, 0.1f);
 147                         Scene->setViewport(vp);
 148                 }
 149                 else
 150                 {
 151                         CViewport       vp;
 152                         vp.initFullScreen();
 153                         Scene->setViewport(vp);
 154                 }
 155         }
 156 };
 157 REGISTER_ACTION_HANDLER (CAHProfileFillRate, "profile_fillrate");
 158
 159 // ------------------------------------------------------------------------------------------------
 160 class CAHProfileTexture : public IActionHandler
 161 {
 162         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 163         {
 164                 if(Driver)
 165                 {
 166                         vector<string>  res;
 167                         Driver->profileTextureUsage(res);
 168
 169                         // Display and save profile to a File.
 170                         CLog    log;
 171                         CFileDisplayer  fileDisplayer(NLMISC::CFile::findNewFile(getLogDirectory() + "texture.log"));
 172                         CStdDisplayer   stdDisplayer;
 173                         log.addDisplayer(&fileDisplayer);
 174                         log.addDisplayer(&stdDisplayer);
 175
 176                         log.displayRawNL("********* TEXTURE PROFILE **********");
 177                         for(uint i=0;i<res.size();i++)
 178                         {
 179                                 log.displayRawNL(res[i].c_str());
 180                         }
 181                         log.displayRawNL("************************************");
 182                 }
 183         }
 184 };
 185 REGISTER_ACTION_HANDLER (CAHProfileTexture, "profile_texture");
 186
 187
 188 // ------------------------------------------------------------------------------------------------
 189 class CAHTogglePACSBorders : public IActionHandler
 190 {
 191         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 192         {
 193                 PACSBorders = !PACSBorders;
 194         }
 195 };
 196 REGISTER_ACTION_HANDLER (CAHTogglePACSBorders, "pacs_borders");
 197
 198 // ------------------------------------------------------------------------------------------------
 199 class CAHToggleDebugClusters : public IActionHandler
 200 {
 201         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 202         {
 203                 DebugClusters = !DebugClusters;
 204         }
 205 };
 206 REGISTER_ACTION_HANDLER (CAHToggleDebugClusters, "debug_clusters");
 207
 208 /*// ------------------------------------------------------------------------------------------------
 209 class CAHToggleSoundBox : public IActionHandler
 210 {
 211         virtual void execute (CCtrlBase *pCaller, const string &Params)
 212         {
 213                 SoundBox = !SoundBox;
 214         }
 215 };
 216 REGISTER_ACTION_HANDLER (CAHToggleSoundBox, "sound_box");
 217 */
 218 // ***************************************************************************
 219 class CAHTest : public IActionHandler
 220 {
 221         void execute(CCtrlBase * /* pCaller */, const std::string &/* params */)
 222         {
 223                 // For test
 224         }
 225 };
 226 // ***************************************************************************
 227 REGISTER_ACTION_HANDLER (CAHTest, "test");
 228
 229 // ***************************************************************************
 230 class CAHRenderMode : public IActionHandler
 231 {
 232         void execute(CCtrlBase * /* pCaller */, const std::string &/* params */)
 233         {
 234                 switch(Driver->getPolygonMode())
 235                 {
 236                 case UDriver::Filled:
 237                         Driver->setPolygonMode(UDriver::Line);
 238                         break;
 239                 case UDriver::Line:
 240                         Driver->setPolygonMode(UDriver::Point);
 241                         break;
 242                 case UDriver::Point:
 243                         Driver->setPolygonMode(UDriver::Filled);
 244                         break;
 245                 }
 246         }
 247 };
 248 // ***************************************************************************
 249 REGISTER_ACTION_HANDLER (CAHRenderMode, "render_mode");
 250
 251 // ***************************************************************************
 252 class CAHToggleRender : public IActionHandler
 253 {
 254         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 255         {
 256                 Render = !Render;
 257         }
 258 };
 259 // ***************************************************************************
 260 REGISTER_ACTION_HANDLER (CAHToggleRender, "toggle_render");
 261
 262 // ***************************************************************************
 263 class CAHSwitchConsoleDisplay : public IActionHandler
 264 {
 265         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 266         {
 267                 //              ChatOutput.switchDisplay();
 268         }
 269 };
 270 // ***************************************************************************
 271 REGISTER_ACTION_HANDLER (CAHSwitchConsoleDisplay, "switch_console_display");
 272
 273 // ***************************************************************************
 274 class CAHToggleFly : public IActionHandler
 275 {
 276         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 277         {
 278                 // Change to AI Mode.
 279                 if(UserControls.mode() != CUserControls::AIMode)
 280                         UserControls.mode(CUserControls::AIMode);
 281                 // Leave the AI Mode.
 282                 else
 283                         UserEntity->viewMode(UserEntity->viewMode());
 284         }
 285 };
 286 // ***************************************************************************
 287 REGISTER_ACTION_HANDLER (CAHToggleFly, "toggle_fly");
 288
 289 // ***************************************************************************
 290 class CAHReloadLandscapeIg : public IActionHandler
 291 {
 292         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 293         {
 294                 if (Landscape)
 295                 {
 296                         if (IGCallbacks) IGCallbacks->deleteIGs();
 297                         LandscapeIGManager.reloadAllIgs ();
 298                         nlassert(IGCallbacks);
 299                         std::vector<UInstanceGroup *> igs;
 300                         LandscapeIGManager.getAllIG(igs);
 301                         if (IGCallbacks) IGCallbacks->addIGs(igs);
 302                 }
 303         }
 304 };
 305 // ***************************************************************************
 306 REGISTER_ACTION_HANDLER (CAHReloadLandscapeIg, "reload_landscape_ig");
 307
 308 // ***************************************************************************
 309 class CAHMemoryReport : public IActionHandler
 310 {
 311         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 312         {
 313 #ifndef NL_USE_DEFAULT_MEMORY_MANAGER
 314 #ifndef NL_HEAP_ALLOCATION_NDEBUG
 315 //              NLMEMORY::StatisticsReport ("memory_stat.csv", false);
 316 #endif // NL_HEAP_ALLOCATION_NDEBUG
 317 #endif // NL_USE_DEFAULT_MEMORY_MANAGER
 318         }
 319 };
 320 // ***************************************************************************
 321 REGISTER_ACTION_HANDLER (CAHMemoryReport, "memory_report");
 322
 323 // ***************************************************************************
 324 class CAHTogglePrimitive: public IActionHandler
 325 {
 326         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 327         {
 328                 PrimFiles.toggleShowHide ();
 329         }
 330 };
 331 // ***************************************************************************
 332 REGISTER_ACTION_HANDLER (CAHTogglePrimitive, "toggle_primitive");
 333
 334 // ***************************************************************************
 335 class CAHPrimBrowseUp : public IActionHandler
 336 {
 337         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 338         {
 339                 PrimFiles.loadNext ();
 340         }
 341 };
 342 // ***************************************************************************
 343 REGISTER_ACTION_HANDLER (CAHPrimBrowseUp, "primitive_up");
 344
 345 // ***************************************************************************
 346 class CAHPrimBrowseDown : public IActionHandler
 347 {
 348         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 349         {
 350                 PrimFiles.loadPrevious ();
 351         }
 352 };
 353 // ***************************************************************************
 354 REGISTER_ACTION_HANDLER (CAHPrimBrowseDown, "primitive_down");
 355
 356 // ***************************************************************************
 357 class CAHToggleMovieRecorder : public IActionHandler
 358 {
 359         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 360         {
 361 #ifdef _MOVIE_SHOOTER_ON_
 362                 if (!MovieShooterSave && !MovieShooterReplay)
 363                 {
 364                         if(!MovieShooter.enabled())
 365                         {
 366                                 Driver->systemMessageBox("MovieShooter not enabled", "MovieShooter");
 367                         }
 368                         else
 369                         {
 370                                 if( !MovieShooterSaving )
 371                                 {
 372                                         // reset the movie, and start a new one
 373                                         MovieShooter.resetMovie();
 374                                         // state
 375                                         MovieShooterSaving= true;
 376                                 }
 377                                 else
 378                                 {
 379                                         // save the movie
 380                                         endMovieShooting();
 381                                 }
 382                         }
 383                 }
 384 #endif // _MOVIE_SHOOTER_ON_
 385         }
 386 };
 387 // ***************************************************************************
 388 REGISTER_ACTION_HANDLER (CAHToggleMovieRecorder, "toggle_movie_recorder");
 389
 390 // ***************************************************************************
 391 class CAHReplayMovie : public IActionHandler
 392 {
 393         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 394         {
 395                 if (!MovieShooterSave && !MovieShooterSaving)
 396                         MovieShooterReplay = true;
 397         }
 398 };
 399 // ***************************************************************************
 400 REGISTER_ACTION_HANDLER (CAHReplayMovie, "replay_movie");
 401
 402 // ***************************************************************************
 403 class CAHSaveMovie : public IActionHandler
 404 {
 405         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 406         {
 407                 if (!MovieShooterReplay && !MovieShooterSaving)
 408                         MovieShooterSave = true;
 409         }
 410 };
 411 // ***************************************************************************
 412 REGISTER_ACTION_HANDLER (CAHSaveMovie, "save_movie");
 413
 414 // ***************************************************************************
 415 class CAHToggleFilter3D : public IActionHandler
 416 {
 417         virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
 418         {
 419 #ifdef  _PROFILE_ON_
 420
 421                 uint32 filter;
 422                 fromString(Params, filter);
 423
 424                 if (filter <= RYZOM_MAX_FILTER_3D)
 425                 {
 426                         Filter3D[filter] = !Filter3D[filter];
 427                         if (filter == FilterVegetable)
 428                         {
 429                                 if (Landscape) Landscape->enableVegetable(Filter3D[FilterVegetable]);
 430                         }
 431                 }
 432 #endif  // _PROFILE_ON_
 433         }
 434 };
 435 // ***************************************************************************
 436 REGISTER_ACTION_HANDLER (CAHToggleFilter3D, "toggle_3d_filter");
 437
 438 // ***************************************************************************
 439 class CAHToggleSeason: public IActionHandler
 440 {
 441         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 442         {
 443                 if (ClientCfg.ManualWeatherSetup)
 444                 {
 445                         ManualSeasonValue = (EGSPD::CSeason::TSeason) (ManualSeasonValue + 1);
 446                         if (ManualSeasonValue == EGSPD::CSeason::Invalid) ManualSeasonValue = EGSPD::CSeason::Spring;
 447                         class CDummyProgress : public NLMISC::IProgressCallback
 448                         {
 449                                 void progress (float /* value */) {}
 450                         };
 451                         CDummyProgress progress;
 452                         ContinentMngr.select(UserEntity->pos(), progress);
 453                 }
 454         }
 455 };
 456 // ***************************************************************************
 457 REGISTER_ACTION_HANDLER (CAHToggleSeason, "toggle_season");
 458
 459 // ***************************************************************************
 460 class CAHReloadSeason: public IActionHandler
 461 {
 462         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 463         {
 464                 // reload all parameters for weather
 465                 loadWorldLightCycle();
 466                 loadWeatherFunctionParams();
 467                 WeatherManager.init();
 468                 ContinentMngr.reloadWeather();
 469         }
 470 };
 471 // ***************************************************************************
 472 REGISTER_ACTION_HANDLER (CAHReloadSeason, "reload_season");
 473
 474
 475 // ***************************************************************************
 476 class CAHWindTest : public IActionHandler
 477 {
 478         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 479         {
 480                 NL3D::UInstance inst = Scene->createInstance("wind.ps");
 481                 if (!inst.empty())
 482                 {
 483                         inst.setPos(MainCam.getPos());
 484                 }
 485         }
 486 };
 487 // ***************************************************************************
 488 REGISTER_ACTION_HANDLER (CAHWindTest, "wind_test");
 489
 490
 491 // ***************************************************************************
 492 class CAHReelWeather : public IActionHandler
 493 {
 494         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 495         {
 496                 ForceTrueWeatherValue = !ForceTrueWeatherValue;
 497         }
 498 };
 499 // ***************************************************************************
 500 REGISTER_ACTION_HANDLER (CAHReelWeather, "real_weather");
 501
 502
 503 // ***************************************************************************
 504 class CAHUpdateClouds: public IActionHandler
 505 {
 506         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 507         {
 508                 InitCloudScape = true;
 509         }
 510 };
 511 // ***************************************************************************
 512 REGISTER_ACTION_HANDLER (CAHUpdateClouds, "update_clouds");
 513
 514
 515 // ***************************************************************************
 516 class CAHToggleWeatherFunction: public IActionHandler
 517 {
 518         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 519         {
 520                 DisplayWeatherFunction = !DisplayWeatherFunction;
 521         }
 522 };
 523 // ***************************************************************************
 524 REGISTER_ACTION_HANDLER (CAHToggleWeatherFunction, "toggle_weather_function");
 525
 526
 527 // ***************************************************************************
 528 class CAHToggleFreezeGraph: public IActionHandler
 529 {
 530         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 531         {
 532                 FreezeGraph = !FreezeGraph;
 533         }
 534 };
 535 // ***************************************************************************
 536 REGISTER_ACTION_HANDLER (CAHToggleFreezeGraph, "toggle_freeze_graph");
 537 #endif // !FINAL_VERSION