RigsofRods
Soft-body Physics Simulation
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
main.cpp
Go to the documentation of this file.
1 /*
2  This source file is part of Rigs of Rods
3  Copyright 2005-2012 Pierre-Michel Ricordel
4  Copyright 2007-2012 Thomas Fischer
5  Copyright 2013-2020 Petr Ohlidal
6 
7  For more information, see http://www.rigsofrods.org/
8 
9  Rigs of Rods is free software: you can redistribute it and/or modify
10  it under the terms of the GNU General Public License version 3, as
11  published by the Free Software Foundation.
12 
13  Rigs of Rods 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 General Public License for more details.
17 
18  You should have received a copy of the GNU General Public License
19  along with Rigs of Rods. If not, see <http://www.gnu.org/licenses/>.
20 */
21 
22 #include "Actor.h"
23 #include "Application.h"
24 #include "AppContext.h"
25 #include "CacheSystem.h"
26 #include "CameraManager.h"
27 #include "ChatSystem.h"
28 #include "Collisions.h"
29 #include "Console.h"
30 #include "ContentManager.h"
31 #include "DiscordRpc.h"
32 #include "ErrorUtils.h"
33 #include "GameContext.h"
34 #include "GfxScene.h"
35 #include "GUI_DirectionArrow.h"
36 #include "GUI_FrictionSettings.h"
37 #include "GUI_GameControls.h"
38 #include "GUI_LoadingWindow.h"
39 #include "GUI_MainSelector.h"
40 #include "GUI_MessageBox.h"
41 #include "GUI_MultiplayerSelector.h"
42 #include "GUI_MultiplayerClientList.h"
43 #include "GUI_RepositorySelector.h"
44 #include "GUI_VehicleInfoTPanel.h"
45 #include "GUIManager.h"
46 #include "GUIUtils.h"
47 #include "InputEngine.h"
48 #include "Language.h"
49 #include "MumbleIntegration.h"
50 #include "OutGauge.h"
51 #include "OverlayWrapper.h"
52 #include "PlatformUtils.h"
53 #include "RoRVersion.h"
54 #include "ScriptEngine.h"
55 #include "Skidmark.h"
56 #include "SoundScriptManager.h"
57 #include "Terrain.h"
58 #include "Utils.h"
59 #include <Overlay/OgreOverlaySystem.h>
60 #include <ctime>
61 #include <iomanip>
62 #include <string>
63 #include <fstream>
64 
65 #ifdef USE_CURL
66 # include <curl/curl.h>
67 #endif //USE_CURL
68 
69 #ifdef __cplusplus
70 extern "C" {
71 #endif
72 
73 int main(int argc, char *argv[])
74 {
75  using namespace RoR;
76 
77 #ifdef USE_CURL
78  curl_global_init(CURL_GLOBAL_ALL); // MUST init before any threads are started
79 #endif
80 
81 #ifndef _DEBUG
82  try
83  {
84 #endif
85 
86  // Create cvars, set default values
87  App::GetConsole()->cVarSetupBuiltins();
88 
89  // Record main thread ID for checks
90  App::GetAppContext()->SetUpThreads();
91 
92  // Update cvars 'sys_process_dir', 'sys_user_dir'
93  if (!App::GetAppContext()->SetUpProgramPaths())
94  {
95  return -1; // Error already displayed
96  }
97 
98  // Create OGRE default logger early
99  App::GetAppContext()->SetUpLogging();
100 
101  // User directories
102  App::sys_config_dir ->setStr(PathCombine(App::sys_user_dir->getStr(), "config"));
103  App::sys_cache_dir ->setStr(PathCombine(App::sys_user_dir->getStr(), "cache"));
104  App::sys_thumbnails_dir->setStr(PathCombine(App::sys_user_dir->getStr(), "thumbnails"));
105  App::sys_savegames_dir ->setStr(PathCombine(App::sys_user_dir->getStr(), "savegames"));
106  App::sys_screenshot_dir->setStr(PathCombine(App::sys_user_dir->getStr(), "screenshots"));
107  App::sys_scripts_dir ->setStr(PathCombine(App::sys_user_dir->getStr(), "scripts"));
108  App::sys_projects_dir ->setStr(PathCombine(App::sys_user_dir->getStr(), "projects"));
109 
110  // Load RoR.cfg - updates cvars
111  App::GetConsole()->loadConfig();
112 
113  // Process command line params - updates 'cli_*' cvars
114  App::GetConsole()->processCommandLine(argc, argv);
115 
116  if (App::app_state->getEnum<AppState>() == AppState::PRINT_HELP_EXIT)
117  {
118  App::GetConsole()->showCommandLineUsage();
119  return 0;
120  }
121  if (App::app_state->getEnum<AppState>() == AppState::PRINT_VERSION_EXIT)
122  {
123  App::GetConsole()->showCommandLineVersion();
124  return 0;
125  }
126 
127  // Find resources dir, update cvar 'sys_resources_dir'
128  if (!App::GetAppContext()->SetUpResourcesDir())
129  {
130  return -1; // Error already displayed
131  }
132 
133  // Make sure config directory exists - to save 'ogre.cfg'
134  CreateFolder(App::sys_config_dir->getStr());
135 
136  // Load and start OGRE renderer, uses config directory
137  if (!App::GetAppContext()->SetUpRendering())
138  {
139  return -1; // Error already displayed
140  }
141 
142  Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);
143 
144  // Deploy base config files from 'skeleton.zip'
145  if (!App::GetAppContext()->SetUpConfigSkeleton())
146  {
147  return -1; // Error already displayed
148  }
149 
150  Ogre::OverlaySystem* overlay_system = new Ogre::OverlaySystem(); //Overlay init
151 
152  Ogre::ConfigOptionMap ropts = App::GetAppContext()->GetOgreRoot()->getRenderSystem()->getConfigOptions();
153  int resolution = Ogre::StringConverter::parseInt(Ogre::StringUtil::split(ropts["Video Mode"].currentValue, " x ")[0], 1024);
154  int fsaa = 2 * (Ogre::StringConverter::parseInt(ropts["FSAA"].currentValue, 0) / 4);
155  int res = std::pow(2, std::floor(std::log2(resolution)));
156 
157  Ogre::TextureManager::getSingleton().createManual ("EnvironmentTexture",
158  Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_CUBE_MAP, res / 4, res / 4, 0,
159  Ogre::PF_R8G8B8, Ogre::TU_RENDERTARGET, 0, false, fsaa);
160  Ogre::TextureManager::getSingleton ().createManual ("Refraction",
161  Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, res / 2, res / 2, 0,
162  Ogre::PF_R8G8B8, Ogre::TU_RENDERTARGET, 0, false, fsaa);
163  Ogre::TextureManager::getSingleton ().createManual ("Reflection",
164  Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, res / 2, res / 2, 0,
165  Ogre::PF_R8G8B8, Ogre::TU_RENDERTARGET, 0, false, fsaa);
166 
167  if (!App::diag_warning_texture->getBool())
168  {
169  // We overwrite the default warning texture (yellow stripes) with something unobtrusive
170  Ogre::uchar data[3] = {0};
171  Ogre::PixelBox pixels(1, 1, 1, Ogre::PF_BYTE_RGB, &data);
172  Ogre::TextureManager::getSingleton()._getWarningTexture()->getBuffer()->blitFromMemory(pixels);
173  }
174 
175  App::GetContentManager()->AddResourcePack(ContentManager::ResourcePack::FLAGS);
176  App::GetContentManager()->AddResourcePack(ContentManager::ResourcePack::FONTS);
177  App::GetContentManager()->AddResourcePack(ContentManager::ResourcePack::ICONS);
178  App::GetContentManager()->AddResourcePack(ContentManager::ResourcePack::OGRE_CORE);
179  App::GetContentManager()->AddResourcePack(ContentManager::ResourcePack::WALLPAPERS);
180  App::GetContentManager()->AddResourcePack(ContentManager::ResourcePack::SCRIPTS);
181 
182 #ifndef NOLANG
183  App::GetLanguageEngine()->setup();
184 #endif // NOLANG
185  App::GetConsole()->regBuiltinCommands(); // Call after localization had been set up
186 
187  App::GetContentManager()->InitContentManager();
188 
189  // Set up rendering
190  App::CreateGfxScene(); // Creates OGRE SceneManager, needs content manager
191  App::GetGfxScene()->GetSceneManager()->addRenderQueueListener(overlay_system);
192  App::CreateCameraManager(); // Creates OGRE Camera
193  App::GetGfxScene()->GetEnvMap().SetupEnvMap(); // Needs camera
194 
195  App::CreateGuiManager(); // Needs scene manager
196 
197  App::GetDiscordRpc()->Init();
198 
199  App::GetAppContext()->SetUpInput();
200 
201 #ifdef USE_ANGELSCRIPT
202  App::CreateScriptEngine();
203  CreateFolder(App::sys_scripts_dir->getStr());
204  CreateFolder(App::sys_projects_dir->getStr());
205 #endif
206 
207  App::GetGuiManager()->SetUpMenuWallpaper();
208 
209  // Add "this is obsolete" marker file to old config location
210  App::GetAppContext()->SetUpObsoleteConfMarker();
211 
212  App::CreateThreadPool();
213 
214  // Load inertia config file
215  App::GetGameContext()->GetActorManager()->GetInertiaConfig().LoadDefaultInertiaModels();
216 
217  // Load mod cache
218  if (App::app_force_cache_purge->getBool())
219  {
220  App::GetGameContext()->PushMessage(Message(MSG_APP_MODCACHE_PURGE_REQUESTED));
221  }
222  else if (App::cli_force_cache_update->getBool() || App::app_force_cache_update->getBool())
223  {
224  App::GetGameContext()->PushMessage(Message(MSG_APP_MODCACHE_UPDATE_REQUESTED));
225  }
226  else
227  {
228  App::GetGameContext()->PushMessage(Message(MSG_APP_MODCACHE_LOAD_REQUESTED));
229  }
230 
231  // Load startup scripts (console, then RoR.cfg)
232  if (App::cli_custom_scripts->getStr() != "")
233  {
234  Ogre::StringVector script_names = Ogre::StringUtil::split(App::cli_custom_scripts->getStr(), ",");
235  for (Ogre::String const& scriptname: script_names)
236  {
237  LOG(fmt::format("Loading startup script '{}' (from command line)", scriptname));
238  App::GetScriptEngine()->loadScript(scriptname, ScriptCategory::CUSTOM);
239  // errors are logged by OGRE & AngelScript
240  }
241  }
242  if (App::app_custom_scripts->getStr() != "")
243  {
244  Ogre::StringVector script_names = Ogre::StringUtil::split(App::app_custom_scripts->getStr(), ",");
245  for (Ogre::String const& scriptname: script_names)
246  {
247  LOG(fmt::format("Loading startup script '{}' (from config file)", scriptname));
248  App::GetScriptEngine()->loadScript(scriptname, ScriptCategory::CUSTOM);
249  // errors are logged by OGRE & AngelScript
250  }
251  }
252 
253  // Handle game state presets
254  if (App::cli_server_host->getStr() != "" && App::cli_server_port->getInt() != 0) // Multiplayer, commandline
255  {
256  App::mp_server_host->setStr(App::cli_server_host->getStr());
257  App::mp_server_port->setVal(App::cli_server_port->getInt());
258  App::GetGameContext()->PushMessage(Message(MSG_NET_CONNECT_REQUESTED));
259  }
260  else if (App::mp_join_on_startup->getBool()) // Multiplayer, conf file
261  {
262  App::GetGameContext()->PushMessage(Message(MSG_NET_CONNECT_REQUESTED));
263  }
264  else // Single player
265  {
266  if (App::cli_preset_terrain->getStr() != "") // Terrain, commandline
267  {
268  App::GetGameContext()->PushMessage(Message(MSG_SIM_LOAD_TERRN_REQUESTED, App::cli_preset_terrain->getStr()));
269  }
270  else if (App::diag_preset_terrain->getStr() != "") // Terrain, conf file
271  {
272  App::GetGameContext()->PushMessage(Message(MSG_SIM_LOAD_TERRN_REQUESTED, App::diag_preset_terrain->getStr()));
273  }
274  else // Main menu
275  {
276  if (App::cli_resume_autosave->getBool())
277  {
278  if (FileExists(PathCombine(App::sys_savegames_dir->getStr(), "autosave.sav")))
279  {
280  App::GetGameContext()->PushMessage(RoR::Message(MSG_SIM_LOAD_SAVEGAME_REQUESTED, "autosave.sav"));
281  }
282  }
283  else if (App::app_skip_main_menu->getBool())
284  {
285  // MainMenu disabled (singleplayer mode) -> go directly to map selector (traditional behavior)
286  RoR::Message m(MSG_GUI_OPEN_SELECTOR_REQUESTED);
287  m.payload = reinterpret_cast<void*>(new LoaderType(LT_Terrain));
288  App::GetGameContext()->PushMessage(m);
289  }
290  else
291  {
292  App::GetGameContext()->PushMessage(Message(MSG_GUI_OPEN_MENU_REQUESTED));
293  }
294  }
295  }
296 
297  App::app_state->setVal((int)AppState::MAIN_MENU);
298  App::GetGuiManager()->MenuWallpaper->show();
299 
300 #ifdef USE_OPENAL
301  if (App::audio_menu_music->getBool())
302  {
303  App::GetSoundScriptManager()->createInstance("tracks/main_menu_tune", -1);
304  SOUND_START(-1, SS_TRIG_MAIN_MENU);
305  }
306 #endif // USE_OPENAL
307 
308  // Hack to properly init DearIMGUI integration - force rendering image
309  // Will be properly fixed under OGRE 2x
310  App::GetGuiManager()->LoadingWindow.SetProgress(100, "Hack", /*renderFrame=*/true);
311  App::GetGuiManager()->LoadingWindow.SetVisible(false);
312 
313  // --------------------------------------------------------------
314  // Main rendering and event handling loop
315  // --------------------------------------------------------------
316 
317  auto start_time = std::chrono::high_resolution_clock::now();
318 
319  while (App::app_state->getEnum<AppState>() != AppState::SHUTDOWN)
320  {
321  OgreBites::WindowEventUtilities::messagePump();
322 
323  // Halt physics (wait for async tasks to finish)
324  if (App::app_state->getEnum<AppState>() == AppState::SIMULATION)
325  {
326  App::GetGameContext()->GetActorManager()->SyncWithSimThread();
327  }
328 
329  // Game events
330  while (App::GetGameContext()->HasMessages())
331  {
332  Message m = App::GetGameContext()->PopMessage();
333  bool failed_m = false;
334  switch (m.type)
335  {
336 
337  // -- Application events --
338 
339  case MSG_APP_SHUTDOWN_REQUESTED:
340  {
341  try
342  {
343  if (App::app_state->getEnum<AppState>() == AppState::SIMULATION)
344  {
345  App::GetGameContext()->SaveScene("autosave.sav");
346  }
347  App::GetConsole()->saveConfig(); // RoR.cfg
348  App::GetDiscordRpc()->Shutdown();
349  #ifdef USE_SOCKETW
350  if (App::mp_state->getEnum<MpState>() == MpState::CONNECTED)
351  {
352  App::GetNetwork()->Disconnect();
353  }
354  #endif // USE_SOCKETW
355  App::app_state->setVal((int)AppState::SHUTDOWN);
356  App::GetScriptEngine()->setEventsEnabled(false); // Hack to enable fast shutdown without cleanup.
357  }
358  catch (...)
359  {
360  HandleMsgQueueException(m.type);
361  }
362  break;
363  }
364 
365  case MSG_APP_SCREENSHOT_REQUESTED:
366  {
367  try
368  {
369  App::GetGuiManager()->SetMouseCursorVisibility(GUIManager::MouseCursorVisibility::HIDDEN);
370  App::GetAppContext()->CaptureScreenshot();
371  App::GetGuiManager()->SetMouseCursorVisibility(GUIManager::MouseCursorVisibility::VISIBLE);
372  }
373  catch (...)
374  {
375  HandleMsgQueueException(m.type);
376  }
377  break;
378  }
379 
380  case MSG_APP_DISPLAY_FULLSCREEN_REQUESTED:
381  {
382  try
383  {
384  App::GetAppContext()->ActivateFullscreen(true);
385  App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_INFO, Console::CONSOLE_SYSTEM_NOTICE,
386  _L("Display mode changed to fullscreen"));
387  }
388  catch (...)
389  {
390  HandleMsgQueueException(m.type);
391  }
392  break;
393  }
394 
395  case MSG_APP_DISPLAY_WINDOWED_REQUESTED:
396  {
397  try
398  {
399  App::GetAppContext()->ActivateFullscreen(false);
400  App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_INFO, Console::CONSOLE_SYSTEM_NOTICE,
401  _L("Display mode changed to windowed"));
402  }
403  catch (...)
404  {
405  HandleMsgQueueException(m.type);
406  }
407  break;
408  }
409 
410  case MSG_APP_MODCACHE_LOAD_REQUESTED:
411  {
412  try
413  {
414  if (!App::GetCacheSystem()->IsModCacheLoaded()) // If not already loaded...
415  {
416  App::GetGuiManager()->SetMouseCursorVisibility(GUIManager::MouseCursorVisibility::HIDDEN);
417  App::GetContentManager()->InitModCache(CacheValidity::UNKNOWN);
418  }
419  }
420  catch (...)
421  {
422  HandleMsgQueueException(m.type);
423  }
424  break;
425  }
426 
427  case MSG_APP_MODCACHE_UPDATE_REQUESTED:
428  {
429  try
430  {
431  if (App::app_state->getEnum<AppState>() == AppState::MAIN_MENU) // No actors must be spawned; they keep pointers to CacheEntries
432  {
433  RoR::Log("[RoR|ModCache] Cache update requested");
434  App::GetGuiManager()->SetMouseCursorVisibility(GUIManager::MouseCursorVisibility::HIDDEN);
435  App::GetContentManager()->InitModCache(CacheValidity::NEEDS_UPDATE);
436  }
437  }
438  catch (...)
439  {
440  HandleMsgQueueException(m.type);
441  }
442  break;
443  }
444 
445  case MSG_APP_MODCACHE_PURGE_REQUESTED:
446  {
447  try
448  {
449  if (App::app_state->getEnum<AppState>() == AppState::MAIN_MENU) // No actors must be spawned; they keep pointers to CacheEntries
450  {
451  RoR::Log("[RoR|ModCache] Cache rebuild requested");
452  App::GetGuiManager()->SetMouseCursorVisibility(GUIManager::MouseCursorVisibility::HIDDEN);
453  App::GetContentManager()->InitModCache(CacheValidity::NEEDS_REBUILD);
454  }
455  }
456  catch (...)
457  {
458  HandleMsgQueueException(m.type);
459  }
460  break;
461  }
462 
463  case MSG_APP_LOAD_SCRIPT_REQUESTED:
464  {
465  LoadScriptRequest* request = static_cast<LoadScriptRequest*>(m.payload);
466  try
467  {
468  ActorPtr actor = App::GetGameContext()->GetActorManager()->GetActorById(request->lsr_associated_actor);
469  ScriptUnitID_t nid = App::GetScriptEngine()->loadScript(request->lsr_filename, request->lsr_category, actor, request->lsr_buffer);
470  // we want to notify any running scripts that we might change something (prevent cheating)
471  App::GetScriptEngine()->triggerEvent(SE_ANGELSCRIPT_MANIPULATIONS,
472  ASMANIP_SCRIPT_LOADED, nid, (int)request->lsr_category, 0, request->lsr_filename);
473  }
474  catch (...)
475  {
476  HandleMsgQueueException(m.type);
477  }
478  delete request;
479  break;
480  }
481 
482  case MSG_APP_UNLOAD_SCRIPT_REQUESTED:
483  {
484  ScriptUnitID_t* id = static_cast<ScriptUnitID_t*>(m.payload);
485  try
486  {
487  ScriptUnit& unit = App::GetScriptEngine()->getScriptUnit(*id);
488  // we want to notify any running scripts that we might change something (prevent cheating)
489  App::GetScriptEngine()->triggerEvent(SE_ANGELSCRIPT_MANIPULATIONS,
490  ASMANIP_SCRIPT_UNLOADING, *id, (int)unit.scriptCategory, 0, unit.scriptName);
491  App::GetScriptEngine()->unloadScript(*id);
492  }
493  catch (...)
494  {
495  HandleMsgQueueException(m.type);
496  }
497  delete id;
498  break;
499  }
500 
501  case MSG_APP_SCRIPT_THREAD_STATUS:
502  {
503  ScriptEventArgs* args = static_cast<ScriptEventArgs*>(m.payload);
504  try
505  {
506  App::GetScriptEngine()->triggerEvent(SE_ANGELSCRIPT_THREAD_STATUS,
507  args->arg1, args->arg2ex, args->arg3ex, args->arg4ex, args->arg5ex, args->arg6ex, args->arg7ex);
508  delete args;
509  }
510  catch (...)
511  {
512  HandleMsgQueueException(m.type);
513  }
514  break;
515  }
516 
517  case MSG_APP_REINIT_INPUT_REQUESTED:
518  {
519  try
520  {
521  LOG(fmt::format("[RoR] !! Reinitializing input engine !!"));
522  App::DestroyInputEngine();
523  App::GetAppContext()->SetUpInput();
524  LOG(fmt::format("[RoR] DONE Reinitializing input engine."));
525  App::GetGuiManager()->LoadingWindow.SetVisible(false); // Shown by `GUI::GameSettings` when changing 'grab mode'
526  }
527  catch (...)
528  {
529  HandleMsgQueueException(m.type);
530  }
531  break;
532  }
533 
534  // -- Network events --
535 
536  case MSG_NET_CONNECT_REQUESTED:
537  {
538 #if USE_SOCKETW
539  try
540  {
541  App::GetNetwork()->StartConnecting();
542  }
543  catch (...)
544  {
545  HandleMsgQueueException(m.type);
546  }
547 #endif
548  break;
549  }
550 
551  case MSG_NET_DISCONNECT_REQUESTED:
552  {
553 #if USE_SOCKETW
554  try
555  {
556  if (App::mp_state->getEnum<MpState>() == MpState::CONNECTED)
557  {
558  App::GetNetwork()->Disconnect();
559  if (App::app_state->getEnum<AppState>() == AppState::MAIN_MENU)
560  {
561  App::GetGuiManager()->MainSelector.Close(); // We may get disconnected while still in map selection
562  App::GetGameContext()->PushMessage(Message(MSG_GUI_OPEN_MENU_REQUESTED));
563  }
564  }
565  }
566  catch (...)
567  {
568  HandleMsgQueueException(m.type);
569  }
570 #endif // USE_SOCKETW
571  break;
572  }
573 
574  case MSG_NET_SERVER_KICK:
575  {
576  try
577  {
578  App::GetGameContext()->PushMessage(Message(MSG_NET_DISCONNECT_REQUESTED));
579  App::GetGameContext()->PushMessage(Message(MSG_SIM_UNLOAD_TERRN_REQUESTED));
580  App::GetGameContext()->PushMessage(Message(MSG_GUI_OPEN_MENU_REQUESTED));
581  App::GetGuiManager()->ShowMessageBox(_LC("Network", "Network disconnected"), m.description.c_str());
582  }
583  catch (...)
584  {
585  HandleMsgQueueException(m.type);
586  }
587  break;
588  }
589 
590  case MSG_NET_RECV_ERROR:
591  {
592  try
593  {
594  App::GetGameContext()->PushMessage(Message(MSG_NET_DISCONNECT_REQUESTED));
595  App::GetGameContext()->PushMessage(Message(MSG_SIM_UNLOAD_TERRN_REQUESTED));
596  App::GetGameContext()->PushMessage(Message(MSG_GUI_OPEN_MENU_REQUESTED));
597  App::GetGuiManager()->ShowMessageBox(_L("Network fatal error: "), m.description.c_str());
598  }
599  catch (...)
600  {
601  HandleMsgQueueException(m.type);
602  }
603  break;
604  }
605 
606  case MSG_NET_CONNECT_STARTED:
607  {
608  try
609  {
610  App::GetGuiManager()->LoadingWindow.SetProgressNetConnect(m.description);
611  App::GetGuiManager()->MultiplayerSelector.SetVisible(false);
612  App::GetGameContext()->PushMessage(Message(MSG_GUI_CLOSE_MENU_REQUESTED));
613  }
614  catch (...)
615  {
616  HandleMsgQueueException(m.type);
617  }
618  break;
619  }
620 
621  case MSG_NET_CONNECT_PROGRESS:
622  {
623  try
624  {
625  App::GetGuiManager()->LoadingWindow.SetProgressNetConnect(m.description);
626  }
627  catch (...)
628  {
629  HandleMsgQueueException(m.type);
630  }
631  break;
632  }
633 
634  case MSG_NET_CONNECT_SUCCESS:
635  {
636 #if USE_SOCKETW
637  try
638  {
639  App::GetGuiManager()->LoadingWindow.SetVisible(false);
640  App::GetNetwork()->StopConnecting();
641  App::mp_state->setVal((int)RoR::MpState::CONNECTED);
642  RoR::ChatSystem::SendStreamSetup();
643  if (!App::GetMumble())
644  {
645  App::CreateMumble();
646  }
647  if (App::GetNetwork()->GetTerrainName() != "any")
648  {
649  App::GetGameContext()->PushMessage(Message(MSG_SIM_LOAD_TERRN_REQUESTED, App::GetNetwork()->GetTerrainName()));
650  }
651  else
652  {
653  // Connected -> go directly to map selector
654  if (App::diag_preset_terrain->getStr().empty())
655  {
656  RoR::Message m(MSG_GUI_OPEN_SELECTOR_REQUESTED);
657  m.payload = reinterpret_cast<void*>(new LoaderType(LT_Terrain));
658  App::GetGameContext()->PushMessage(m);
659  }
660  else
661  {
662  App::GetGameContext()->PushMessage(Message(MSG_SIM_LOAD_TERRN_REQUESTED, App::diag_preset_terrain->getStr()));
663  }
664  }
665  }
666  catch (...)
667  {
668  HandleMsgQueueException(m.type);
669  }
670 #endif // USE_SOCKETW
671  break;
672  }
673 
674  case MSG_NET_CONNECT_FAILURE:
675  {
676 #if USE_SOCKETW
677  try
678  {
679  App::GetGuiManager()->LoadingWindow.SetVisible(false);
680  App::GetNetwork()->StopConnecting();
681  App::GetGameContext()->PushMessage(Message(MSG_NET_DISCONNECT_REQUESTED));
682  App::GetGameContext()->PushMessage(Message(MSG_GUI_OPEN_MENU_REQUESTED));
683  App::GetGuiManager()->ShowMessageBox(
684  _LC("Network", "Multiplayer: connection failed"), m.description.c_str());
685  }
686  catch (...)
687  {
688  HandleMsgQueueException(m.type);
689  }
690 #endif // USE_SOCKETW
691  break;
692  }
693 
694  case MSG_NET_REFRESH_SERVERLIST_SUCCESS:
695  {
696  GUI::MpServerInfoVec* data = static_cast<GUI::MpServerInfoVec*>(m.payload);
697  try
698  {
699  App::GetGuiManager()->MultiplayerSelector.UpdateServerlist(data);
700  }
701  catch (...)
702  {
703  HandleMsgQueueException(m.type);
704  }
705  delete data;
706  break;
707  }
708 
709  case MSG_NET_REFRESH_SERVERLIST_FAILURE:
710  {
711  CurlFailInfo* failinfo = static_cast<CurlFailInfo*>(m.payload);
712  try
713  {
714  App::GetGuiManager()->MultiplayerSelector.DisplayRefreshFailed(failinfo);
715  }
716  catch (...)
717  {
718  HandleMsgQueueException(m.type);
719  }
720  delete failinfo;
721  break;
722  }
723 
724  case MSG_NET_REFRESH_REPOLIST_SUCCESS:
725  {
726  GUI::ResourcesCollection* data = static_cast<GUI::ResourcesCollection*>(m.payload);
727  try
728  {
729  App::GetGuiManager()->RepositorySelector.UpdateResources(data);
730  }
731  catch (...)
732  {
733  HandleMsgQueueException(m.type);
734  }
735  delete data;
736  break;
737  }
738 
739  case MSG_NET_OPEN_RESOURCE_SUCCESS:
740  {
741  GUI::ResourcesCollection* data = static_cast<GUI::ResourcesCollection*>(m.payload);
742  try
743  {
744  App::GetGuiManager()->RepositorySelector.UpdateFiles(data);
745  }
746  catch (...)
747  {
748  HandleMsgQueueException(m.type);
749  }
750  delete data;
751  break;
752  }
753 
754  case MSG_NET_REFRESH_REPOLIST_FAILURE:
755  {
756  CurlFailInfo* failinfo = static_cast<CurlFailInfo*>(m.payload);
757  try
758  {
759  App::GetGuiManager()->RepositorySelector.ShowError(failinfo);
760  }
761  catch (...)
762  {
763  HandleMsgQueueException(m.type);
764  }
765  delete failinfo;
766  break;
767  }
768 
769  case MSG_NET_FETCH_AI_PRESETS_SUCCESS:
770  {
771  try
772  {
773  App::GetGuiManager()->TopMenubar.ai_presets_extern_fetching = false;
774  App::GetGuiManager()->TopMenubar.ai_presets_extern.Parse(m.description.c_str());
775  App::GetGuiManager()->TopMenubar.RefreshAiPresets();
776  }
777  catch (...)
778  {
779  HandleMsgQueueException(m.type);
780  }
781  break;
782  }
783 
784  case MSG_NET_FETCH_AI_PRESETS_FAILURE:
785  {
786  try
787  {
788  App::GetGuiManager()->TopMenubar.ai_presets_extern_fetching = false;
789  App::GetGuiManager()->TopMenubar.ai_presets_extern_error = m.description;
790  App::GetGuiManager()->TopMenubar.RefreshAiPresets();
791  }
792  catch (...)
793  {
794  HandleMsgQueueException(m.type);
795  }
796  break;
797  }
798 
799  case MSG_NET_ADD_PEEROPTIONS_REQUESTED:
800  {
801  PeerOptionsRequest* request = static_cast<PeerOptionsRequest*>(m.payload);
802  try
803  {
804  // Record the options for future incoming traffic.
805  App::GetNetwork()->AddPeerOptions(request);
806 
807  // On MUTE_CHAT also purge old messages
808  if (BITMASK_IS_1(request->por_peeropts, RoRnet::PEEROPT_MUTE_CHAT))
809  {
810  App::GetConsole()->purgeNetChatMessagesByUser(request->por_uid);
811  }
812 
813  // MUTE existing actors if needed
814  if (BITMASK_IS_1(request->por_peeropts, RoRnet::PEEROPT_MUTE_ACTORS))
815  {
816  for (ActorPtr& actor : App::GetGameContext()->GetActorManager()->GetActors())
817  {
818  if (actor->ar_net_source_id == request->por_uid)
819  {
820  App::GetGameContext()->PushMessage(Message(MSG_SIM_MUTE_NET_ACTOR_REQUESTED, new ActorPtr(actor)));
821  }
822  }
823  }
824 
825  // HIDE existing actors if needed
826  if (BITMASK_IS_1(request->por_peeropts, RoRnet::PEEROPT_HIDE_ACTORS))
827  {
828  for (ActorPtr& actor : App::GetGameContext()->GetActorManager()->GetActors())
829  {
830  if (actor->ar_net_source_id == request->por_uid)
831  {
832  App::GetGameContext()->PushMessage(Message(MSG_SIM_HIDE_NET_ACTOR_REQUESTED, new ActorPtr(actor)));
833  }
834  }
835  }
836  }
837  catch (...)
838  {
839  HandleMsgQueueException(m.type);
840  }
841  delete request;
842  break;
843  }
844 
845  case MSG_NET_REMOVE_PEEROPTIONS_REQUESTED:
846  {
847  PeerOptionsRequest* request = static_cast<PeerOptionsRequest*>(m.payload);
848  try
849  {
850  // Record the options for future incoming traffic.
851  App::GetNetwork()->RemovePeerOptions(request);
852 
853  // un-MUTE existing actors if needed
854  if (BITMASK_IS_1(request->por_peeropts, RoRnet::PEEROPT_MUTE_ACTORS))
855  {
856  for (ActorPtr& actor : App::GetGameContext()->GetActorManager()->GetActors())
857  {
858  if (actor->ar_net_source_id == request->por_uid)
859  {
860  App::GetGameContext()->PushMessage(Message(MSG_SIM_UNMUTE_NET_ACTOR_REQUESTED, new ActorPtr(actor)));
861  }
862  }
863  }
864 
865  // un-HIDE existing actors if needed
866  if (BITMASK_IS_1(request->por_peeropts, RoRnet::PEEROPT_HIDE_ACTORS))
867  {
868  for (ActorPtr& actor : App::GetGameContext()->GetActorManager()->GetActors())
869  {
870  if (actor->ar_net_source_id == request->por_uid)
871  {
872  App::GetGameContext()->PushMessage(Message(MSG_SIM_UNHIDE_NET_ACTOR_REQUESTED, new ActorPtr(actor)));
873  }
874  }
875  }
876  }
877  catch (...)
878  {
879  HandleMsgQueueException(m.type);
880  }
881  delete request;
882  break;
883  }
884 
885  // -- Gameplay events --
886 
887  case MSG_SIM_PAUSE_REQUESTED:
888  {
889  try
890  {
891  for (ActorPtr& actor: App::GetGameContext()->GetActorManager()->GetActors())
892  {
893  actor->muteAllSounds();
894  }
895  App::sim_state->setVal((int)SimState::PAUSED);
896  }
897  catch (...)
898  {
899  HandleMsgQueueException(m.type);
900  }
901  break;
902  }
903 
904  case MSG_SIM_UNPAUSE_REQUESTED:
905  {
906  try
907  {
908  for (ActorPtr& actor: App::GetGameContext()->GetActorManager()->GetActors())
909  {
910  if (!actor->ar_muted_by_peeropt)
911  {
912  actor->unmuteAllSounds();
913  }
914  }
915  App::sim_state->setVal((int)SimState::RUNNING);
916  }
917  catch (...)
918  {
919  HandleMsgQueueException(m.type);
920  }
921  break;
922  }
923 
924  case MSG_SIM_LOAD_TERRN_REQUESTED:
925  {
926  try
927  {
928  App::GetGuiManager()->SetMouseCursorVisibility(GUIManager::MouseCursorVisibility::HIDDEN);
929  App::GetGuiManager()->LoadingWindow.SetProgress(5, _L("Loading resources"));
930  App::GetContentManager()->LoadGameplayResources();
931 
932  if (App::GetGameContext()->LoadTerrain(m.description))
933  {
934  App::GetGameContext()->CreatePlayerCharacter();
935  // Spawn preselected vehicle; commandline has precedence
936  if (App::cli_preset_vehicle->getStr() != "")
937  App::GetGameContext()->SpawnPreselectedActor(App::cli_preset_vehicle->getStr(), App::cli_preset_veh_config->getStr()); // Needs character for position
938  else if (App::diag_preset_vehicle->getStr() != "")
939  App::GetGameContext()->SpawnPreselectedActor(App::diag_preset_vehicle->getStr(), App::diag_preset_veh_config->getStr()); // Needs character for position
940  App::GetGameContext()->GetSceneMouse().InitializeVisuals();
941  App::CreateOverlayWrapper();
942  App::GetGuiManager()->DirectionArrow.LoadOverlay();
943  if (App::audio_menu_music->getBool())
944  {
945  SOUND_KILL(-1, SS_TRIG_MAIN_MENU);
946  }
947  if (App::gfx_sky_mode->getEnum<GfxSkyMode>() == GfxSkyMode::SANDSTORM)
948  {
949  App::GetGfxScene()->GetSceneManager()->setAmbientLight(Ogre::ColourValue(0.7f, 0.7f, 0.7f));
950  }
951  else
952  {
953  App::GetGfxScene()->GetSceneManager()->setAmbientLight(Ogre::ColourValue(0.3f, 0.3f, 0.3f));
954  }
955  App::GetDiscordRpc()->UpdatePresence();
956  App::sim_state->setVal((int)SimState::RUNNING);
957  App::app_state->setVal((int)AppState::SIMULATION);
958  App::GetGuiManager()->GameMainMenu .SetVisible(false);
959  App::GetGuiManager()->MenuWallpaper->hide();
960  App::GetGuiManager()->LoadingWindow.SetVisible(false);
961  App::GetGuiManager()->SetMouseCursorVisibility(GUIManager::MouseCursorVisibility::VISIBLE);
962  App::gfx_fov_external->setVal(App::gfx_fov_external_default->getInt());
963  App::gfx_fov_internal->setVal(App::gfx_fov_internal_default->getInt());
964  #ifdef USE_SOCKETW
965  if (App::mp_state->getEnum<MpState>() == MpState::CONNECTED)
966  {
967  App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_INFO, Console::CONSOLE_SYSTEM_NOTICE,
968  fmt::format(_LC("ChatBox", "Press {} to start chatting"),
969  App::GetInputEngine()->getEventCommandTrimmed(EV_COMMON_ENTER_CHATMODE)), "lightbulb.png");
970  }
971  #endif // USE_SOCKETW
972  if (App::io_outgauge_mode->getInt() > 0)
973  {
974  App::GetOutGauge()->Connect();
975  }
976  }
977  else
978  {
979  if (App::mp_state->getEnum<MpState>() == MpState::CONNECTED)
980  {
981  App::GetGameContext()->PushMessage(Message(MSG_NET_DISCONNECT_REQUESTED));
982  }
983  else
984  {
985  App::GetGameContext()->PushMessage(Message(MSG_GUI_OPEN_MENU_REQUESTED));
986  }
987  App::GetGuiManager()->LoadingWindow.SetVisible(false);
988  failed_m = true;
989  }
990  }
991  catch (...)
992  {
993  HandleMsgQueueException(m.type);
994  }
995  break;
996  }
997 
998  case MSG_SIM_UNLOAD_TERRN_REQUESTED:
999  {
1000  try
1001  {
1002  if (App::sim_state->getEnum<SimState>() == SimState::EDITOR_MODE)
1003  {
1004  App::GetGameContext()->GetTerrain()->GetTerrainEditor()->WriteOutputFile();
1005  }
1006  App::GetGameContext()->SaveScene("autosave.sav");
1007  App::GetGameContext()->ChangePlayerActor(nullptr);
1008  App::GetGameContext()->GetActorManager()->CleanUpSimulation();
1009  App::GetGameContext()->GetCharacterFactory()->DeleteAllCharacters();
1010  App::GetGameContext()->GetSceneMouse().DiscardVisuals();
1011  App::DestroyOverlayWrapper();
1012  App::GetCameraManager()->ResetAllBehaviors();
1013  App::GetGuiManager()->CollisionsDebug.CleanUp();
1014  App::GetGuiManager()->MainSelector.Close();
1015  App::GetGuiManager()->LoadingWindow.SetVisible(false);
1016  App::GetGuiManager()->MenuWallpaper->show();
1017  App::GetGuiManager()->TopMenubar.ai_waypoints.clear();
1018  App::sim_state->setVal((int)SimState::OFF);
1019  App::app_state->setVal((int)AppState::MAIN_MENU);
1020  App::GetGameContext()->UnloadTerrain();
1021  App::GetGfxScene()->ClearScene();
1022  App::sim_terrain_name->setStr("");
1023  App::sim_terrain_gui_name->setStr("");
1024  App::GetOutGauge()->Close();
1025  App::GetSoundScriptManager()->setCamera(/*position:*/Ogre::Vector3::ZERO, /*direction:*/Ogre::Vector3::ZERO, /*up:*/Ogre::Vector3::UNIT_Y, /*velocity:*/Ogre::Vector3::ZERO);
1026  App::GetGameContext()->GetRaceSystem().ResetRaceUI();
1027  }
1028  catch (...)
1029  {
1030  HandleMsgQueueException(m.type);
1031  }
1032  break;
1033  }
1034 
1035  case MSG_SIM_LOAD_SAVEGAME_REQUESTED:
1036  {
1037  try
1038  {
1039  std::string terrn_filename = App::GetGameContext()->ExtractSceneTerrain(m.description);
1040  if (terrn_filename == "")
1041  {
1042  Str<400> msg; msg << _L("Could not read savegame file") << "'" << m.description << "'";
1043  App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_INFO, Console::CONSOLE_SYSTEM_ERROR, msg.ToCStr());
1044  if (App::app_state->getEnum<AppState>() == AppState::MAIN_MENU)
1045  {
1046  App::GetGameContext()->PushMessage(Message(MSG_GUI_OPEN_MENU_REQUESTED));
1047  }
1048  }
1049  else if (terrn_filename == App::sim_terrain_name->getStr())
1050  {
1051  App::GetGameContext()->LoadScene(m.description);
1052  }
1053  else if (terrn_filename != App::sim_terrain_name->getStr() && App::mp_state->getEnum<MpState>() == MpState::CONNECTED)
1054  {
1055  Str<400> msg; msg << _L("Error while loading scene: Terrain mismatch");
1056  App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_INFO, Console::CONSOLE_SYSTEM_ERROR, msg.ToCStr());
1057  }
1058  else
1059  {
1060  if (App::sim_terrain_name->getStr() != "")
1061  {
1062  App::GetGameContext()->PushMessage(Message(MSG_SIM_UNLOAD_TERRN_REQUESTED));
1063  }
1064 
1065  RoR::LogFormat("[RoR|Savegame] Loading terrain '%s' ...", terrn_filename.c_str());
1066  App::GetGameContext()->PushMessage(Message(MSG_SIM_LOAD_TERRN_REQUESTED, terrn_filename));
1067  // Loading terrain may produce actor-spawn requests; the savegame-request must be posted after them.
1068  App::GetGameContext()->ChainMessage(Message(MSG_SIM_LOAD_SAVEGAME_REQUESTED, m.description));
1069  }
1070  }
1071  catch (...)
1072  {
1073  HandleMsgQueueException(m.type);
1074  }
1075  break;
1076  }
1077 
1078  case MSG_SIM_SPAWN_ACTOR_REQUESTED:
1079  {
1080  ActorSpawnRequest* rq = static_cast<ActorSpawnRequest*>(m.payload);
1081  try
1082  {
1083  if (App::app_state->getEnum<AppState>() == AppState::SIMULATION)
1084  {
1085  App::GetGameContext()->SpawnActor(*rq);
1086  }
1087  }
1088  catch (...)
1089  {
1090  HandleMsgQueueException(m.type);
1091  }
1092  delete rq;
1093  break;
1094  }
1095 
1096  case MSG_SIM_MODIFY_ACTOR_REQUESTED:
1097  {
1098  ActorModifyRequest* rq = static_cast<ActorModifyRequest*>(m.payload);
1099  try
1100  {
1101  if (App::app_state->getEnum<AppState>() == AppState::SIMULATION)
1102  {
1103  App::GetGameContext()->ModifyActor(*rq);
1104  }
1105  }
1106  catch (...)
1107  {
1108  HandleMsgQueueException(m.type);
1109  }
1110  delete rq;
1111  break;
1112  }
1113 
1114  case MSG_SIM_DELETE_ACTOR_REQUESTED:
1115  {
1116  ActorPtr* actor_ptr = static_cast<ActorPtr*>(m.payload);
1117  try
1118  {
1119  ROR_ASSERT(actor_ptr);
1120  if (App::app_state->getEnum<AppState>() == AppState::SIMULATION)
1121  {
1122  App::GetGameContext()->DeleteActor(*actor_ptr);
1123  }
1124  }
1125  catch (...)
1126  {
1127  HandleMsgQueueException(m.type);
1128  }
1129  delete actor_ptr;
1130  break;
1131  }
1132 
1133  case MSG_SIM_SEAT_PLAYER_REQUESTED:
1134  {
1135  ActorPtr* actor_ptr = static_cast<ActorPtr*>(m.payload);
1136  try
1137  {
1138  ROR_ASSERT(actor_ptr); // Even if leaving vehicle, the pointer must be valid.
1139  if (App::app_state->getEnum<AppState>() == AppState::SIMULATION)
1140  {
1141  App::GetGameContext()->ChangePlayerActor(*actor_ptr);
1142  }
1143  }
1144  catch (...)
1145  {
1146  HandleMsgQueueException(m.type);
1147  }
1148  delete actor_ptr;
1149  break;
1150  }
1151 
1152  case MSG_SIM_TELEPORT_PLAYER_REQUESTED:
1153  {
1154  Ogre::Vector3* pos = static_cast<Ogre::Vector3*>(m.payload);
1155  try
1156  {
1157  if (App::app_state->getEnum<AppState>() == AppState::SIMULATION)
1158  {
1159  App::GetGameContext()->TeleportPlayer(pos->x, pos->z);
1160  }
1161  }
1162  catch (...)
1163  {
1164  HandleMsgQueueException(m.type);
1165  }
1166  delete pos;
1167  break;
1168  }
1169 
1170  case MSG_SIM_HIDE_NET_ACTOR_REQUESTED:
1171  {
1172  ActorPtr* actor_ptr = static_cast<ActorPtr*>(m.payload);
1173  try
1174  {
1175  ROR_ASSERT(actor_ptr);
1176  if ((App::mp_state->getEnum<MpState>() == MpState::CONNECTED) &&
1177  ((*actor_ptr)->ar_state == ActorState::NETWORKED_OK))
1178  {
1179  ActorPtr actor = *actor_ptr;
1180  actor->ar_state = ActorState::NETWORKED_HIDDEN; // Stop net. updates
1181  App::GetGfxScene()->RemoveGfxActor(actor->GetGfxActor()); // Remove visuals (also stops updating SimBuffer)
1182  actor->GetGfxActor()->GetSimDataBuffer().simbuf_actor_state = ActorState::NETWORKED_HIDDEN; // Hack - manually propagate the new state to SimBuffer so Character can reflect it.
1183  actor->GetGfxActor()->SetAllMeshesVisible(false);
1184  actor->GetGfxActor()->SetCastShadows(false);
1185  actor->muteAllSounds(); // Stop sounds
1186  actor->forceAllFlaresOff();
1187  actor->setSmokeEnabled(false);
1188  }
1189  }
1190  catch (...)
1191  {
1192  HandleMsgQueueException(m.type);
1193  }
1194  delete actor_ptr;
1195  break;
1196  }
1197 
1198  case MSG_SIM_UNHIDE_NET_ACTOR_REQUESTED:
1199  {
1200  ActorPtr* actor_ptr = static_cast<ActorPtr*>(m.payload);
1201  try
1202  {
1203  ROR_ASSERT(actor_ptr);
1204  if (App::mp_state->getEnum<MpState>() == MpState::CONNECTED &&
1205  ((*actor_ptr)->ar_state == ActorState::NETWORKED_HIDDEN))
1206  {
1207  ActorPtr actor = *actor_ptr;
1208  actor->ar_state = ActorState::NETWORKED_OK; // Resume net. updates
1209  App::GetGfxScene()->RegisterGfxActor(actor->GetGfxActor()); // Restore visuals (also resumes updating SimBuffer)
1210  actor->GetGfxActor()->SetAllMeshesVisible(true);
1211  actor->GetGfxActor()->SetCastShadows(true);
1212  actor->unmuteAllSounds(); // Unmute sounds
1213  actor->setSmokeEnabled(true);
1214  }
1215  }
1216  catch (...)
1217  {
1218  HandleMsgQueueException(m.type);
1219  }
1220  delete actor_ptr;
1221  break;
1222  }
1223 
1224  case MSG_SIM_MUTE_NET_ACTOR_REQUESTED:
1225  {
1226  ActorPtr* actor_ptr = static_cast<ActorPtr*>(m.payload);
1227  try
1228  {
1229  ROR_ASSERT(actor_ptr);
1230  if ((App::mp_state->getEnum<MpState>() == MpState::CONNECTED) &&
1231  ((*actor_ptr)->ar_state == ActorState::NETWORKED_OK))
1232  {
1233  ActorPtr actor = *actor_ptr;
1234  actor->ar_muted_by_peeropt = true;
1235  actor->muteAllSounds();
1236  }
1237  }
1238  catch (...)
1239  {
1240  HandleMsgQueueException(m.type);
1241  }
1242  delete actor_ptr;
1243  break;
1244  }
1245 
1246  case MSG_SIM_UNMUTE_NET_ACTOR_REQUESTED:
1247  {
1248  ActorPtr* actor_ptr = static_cast<ActorPtr*>(m.payload);
1249  try
1250  {
1251  ROR_ASSERT(actor_ptr);
1252  if ((App::mp_state->getEnum<MpState>() == MpState::CONNECTED) &&
1253  ((*actor_ptr)->ar_state == ActorState::NETWORKED_OK))
1254  {
1255  ActorPtr actor = *actor_ptr;
1256  actor->ar_muted_by_peeropt = false;
1257  actor->unmuteAllSounds();
1258  }
1259  }
1260  catch (...)
1261  {
1262  HandleMsgQueueException(m.type);
1263  }
1264  delete actor_ptr;
1265  break;
1266  }
1267 
1268  case MSG_SIM_SCRIPT_EVENT_TRIGGERED:
1269  {
1270  ScriptEventArgs* args = static_cast<ScriptEventArgs*>(m.payload);
1271  try
1272  {
1273  App::GetScriptEngine()->triggerEvent(args->type, args->arg1, args->arg2ex, args->arg3ex, args->arg4ex, args->arg5ex, args->arg6ex, args->arg7ex, args->arg8ex);
1274  }
1275  catch (...)
1276  {
1277  HandleMsgQueueException(m.type);
1278  }
1279  delete args;
1280  break;
1281  }
1282 
1283  case MSG_SIM_SCRIPT_CALLBACK_QUEUED:
1284  {
1285  ScriptCallbackArgs* args = static_cast<ScriptCallbackArgs*>(m.payload);
1286  try
1287  {
1288  App::GetScriptEngine()->envokeCallback(args->eventsource->es_script_handler, args->eventsource, args->node);
1289  }
1290  catch (...)
1291  {
1292  HandleMsgQueueException(m.type);
1293  }
1294  delete args;
1295  break;
1296  }
1297 
1298  case MSG_SIM_ACTOR_LINKING_REQUESTED:
1299  {
1300  // Estabilishing a physics linkage between 2 actors modifies a global linkage table
1301  // and triggers immediate update of every actor's linkage tables,
1302  // so it has to be done sequentially on main thread.
1303  // ---------------------------------------------------------------------------------
1304  ActorLinkingRequest* request = static_cast<ActorLinkingRequest*>(m.payload);
1305  try
1306  {
1307  ActorPtr actor = App::GetGameContext()->GetActorManager()->GetActorById(request->alr_actor_instance_id);
1308  if (actor)
1309  {
1310  switch (request->alr_type)
1311  {
1312  case ActorLinkingRequestType::HOOK_LOCK:
1313  case ActorLinkingRequestType::HOOK_UNLOCK:
1314  case ActorLinkingRequestType::HOOK_TOGGLE:
1315  actor->hookToggle(request->alr_hook_group, request->alr_type);
1316  break;
1317 
1318  case ActorLinkingRequestType::HOOK_MOUSE_TOGGLE:
1319  actor->hookToggle(request->alr_hook_group, request->alr_type, request->alr_hook_mousenode);
1320  TRIGGER_EVENT_ASYNC(SE_TRUCK_MOUSE_GRAB, request->alr_actor_instance_id);
1321  break;
1322 
1323  case ActorLinkingRequestType::TIE_TOGGLE:
1324  actor->tieToggle(request->alr_tie_group);
1325  break;
1326 
1327  case ActorLinkingRequestType::ROPE_TOGGLE:
1328  actor->ropeToggle(request->alr_rope_group);
1329  break;
1330 
1331  case ActorLinkingRequestType::SLIDENODE_TOGGLE:
1332  actor->toggleSlideNodeLock();
1333  break;
1334  }
1335  }
1336  }
1337  catch (...)
1338  {
1339  HandleMsgQueueException(m.type);
1340  }
1341  delete request;
1342  break;
1343  }
1344 
1345  case MSG_SIM_ADD_FREEFORCE_REQUESTED:
1346  {
1347  FreeForceRequest* rq = static_cast<FreeForceRequest*>(m.payload);
1348  try
1349  {
1350  App::GetGameContext()->GetActorManager()->AddFreeForce(rq);
1351  }
1352  catch (...)
1353  {
1354  HandleMsgQueueException(m.type);
1355  }
1356  delete rq;
1357  break;
1358  }
1359 
1360  case MSG_SIM_MODIFY_FREEFORCE_REQUESTED:
1361  {
1362  FreeForceRequest* rq = static_cast<FreeForceRequest*>(m.payload);
1363  try
1364  {
1365  App::GetGameContext()->GetActorManager()->ModifyFreeForce(rq);
1366  }
1367  catch (...)
1368  {
1369  HandleMsgQueueException(m.type);
1370  }
1371  delete rq;
1372  break;
1373  }
1374 
1375  case MSG_SIM_REMOVE_FREEFORCE_REQUESTED:
1376  {
1377  FreeForceID_t* rq = static_cast<FreeForceID_t*>(m.payload);
1378  try
1379  {
1380  App::GetGameContext()->GetActorManager()->RemoveFreeForce(*rq);
1381  }
1382  catch (...)
1383  {
1384  HandleMsgQueueException(m.type);
1385  }
1386  delete rq;
1387  break;
1388  }
1389 
1390  // -- GUI events ---
1391 
1392  case MSG_GUI_OPEN_MENU_REQUESTED:
1393  {
1394  try
1395  {
1396  App::GetGuiManager()->GameMainMenu.SetVisible(true);
1397  }
1398  catch (...)
1399  {
1400  HandleMsgQueueException(m.type);
1401  }
1402  break;
1403  }
1404 
1405  case MSG_GUI_CLOSE_MENU_REQUESTED:
1406  {
1407  try
1408  {
1409  App::GetGuiManager()->GameMainMenu.SetVisible(false);
1410  }
1411  catch (...)
1412  {
1413  HandleMsgQueueException(m.type);
1414  }
1415  break;
1416  }
1417 
1418  case MSG_GUI_OPEN_SELECTOR_REQUESTED:
1419  {
1420  LoaderType* type = static_cast<LoaderType*>(m.payload);
1421  try
1422  {
1423  App::GetGuiManager()->MainSelector.Show(*type, m.description);
1424  }
1425  catch (...)
1426  {
1427  HandleMsgQueueException(m.type);
1428  }
1429  delete type;
1430  break;
1431  }
1432 
1433  case MSG_GUI_CLOSE_SELECTOR_REQUESTED:
1434  {
1435  try
1436  {
1437  App::GetGuiManager()->MainSelector.Close();
1438  }
1439  catch (...)
1440  {
1441  HandleMsgQueueException(m.type);
1442  }
1443  break;
1444  }
1445 
1446  case MSG_GUI_MP_CLIENTS_REFRESH:
1447  {
1448  try
1449  {
1450  App::GetGuiManager()->MpClientList.UpdateClients();
1451  }
1452  catch (...)
1453  {
1454  HandleMsgQueueException(m.type);
1455  }
1456  break;
1457  }
1458 
1459  case MSG_GUI_SHOW_MESSAGE_BOX_REQUESTED:
1460  {
1461  GUI::MessageBoxConfig* conf = static_cast<GUI::MessageBoxConfig*>(m.payload);
1462  try
1463  {
1464  App::GetGuiManager()->ShowMessageBox(*conf);
1465  }
1466  catch (...)
1467  {
1468  HandleMsgQueueException(m.type);
1469  }
1470  delete conf;
1471  break;
1472  }
1473 
1474  case MSG_GUI_DOWNLOAD_PROGRESS:
1475  {
1476  int* percentage = static_cast<int*>(m.payload);
1477  try
1478  {
1479  App::GetGameContext()->PushMessage(Message(MSG_GUI_CLOSE_MENU_REQUESTED));
1480  App::GetGuiManager()->LoadingWindow.SetProgress(*percentage, m.description, false);
1481  }
1482  catch (...)
1483  {
1484  HandleMsgQueueException(m.type);
1485  }
1486  delete percentage;
1487  break;
1488  }
1489 
1490  case MSG_GUI_DOWNLOAD_FINISHED:
1491  {
1492  try
1493  {
1494  App::GetGuiManager()->LoadingWindow.SetVisible(false);
1495  App::GetGuiManager()->RepositorySelector.SetVisible(true);
1496  App::GetGuiManager()->RepositorySelector.DownloadFinished();
1497  }
1498  catch (...)
1499  {
1500  HandleMsgQueueException(m.type);
1501  }
1502  break;
1503  }
1504 
1505  case MSG_GUI_REFRESH_TUNING_MENU_REQUESTED:
1506  {
1507  try
1508  {
1509  App::GetGuiManager()->TopMenubar.RefreshTuningMenu();
1510  }
1511  catch (...)
1512  {
1513  HandleMsgQueueException(m.type);
1514  }
1515  break;
1516  }
1517 
1518  case MSG_GUI_SHOW_CHATBOX_REQUESTED:
1519  {
1520  try
1521  {
1522  App::GetGuiManager()->ChatBox.SetVisible(true);
1523  if (m.description != "")
1524  {
1525  App::GetGuiManager()->ChatBox.AssignBuffer(m.description);
1526  }
1527  }
1528  catch (...)
1529  {
1530  HandleMsgQueueException(m.type);
1531  }
1532  break;
1533  }
1534 
1535  // -- Editing events --
1536 
1537  case MSG_EDI_MODIFY_GROUNDMODEL_REQUESTED:
1538  {
1539  try
1540  {
1541  ground_model_t* modified_gm = static_cast<ground_model_t*>(m.payload);
1542  ground_model_t* live_gm = App::GetGameContext()->GetTerrain()->GetCollisions()->getGroundModelByString(modified_gm->name);
1543  *live_gm = *modified_gm; // Copy over
1544  //DO NOT `delete` the payload - it's a weak pointer, the data are owned by `RoR::Collisions`; See `enum MsgType` in file 'Application.h'.
1545  }
1546  catch (...)
1547  {
1548  HandleMsgQueueException(m.type);
1549  }
1550  break;
1551  }
1552 
1553  case MSG_EDI_ENTER_TERRN_EDITOR_REQUESTED:
1554  {
1555  try
1556  {
1557  if (App::sim_state->getEnum<SimState>() != SimState::EDITOR_MODE)
1558  {
1559  App::sim_state->setVal((int)SimState::EDITOR_MODE);
1560  App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_INFO, Console::CONSOLE_SYSTEM_NOTICE,
1561  _L("Entered terrain editing mode"));
1562 
1563  App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_INFO, Console::CONSOLE_SYSTEM_NOTICE,
1564  fmt::format(_L("Press {} or middle mouse click to select an object"),
1565  App::GetInputEngine()->getEventCommandTrimmed(EV_COMMON_ENTER_OR_EXIT_TRUCK)), "lightbulb.png");
1566 
1567  }
1568  }
1569  catch (...)
1570  {
1571  HandleMsgQueueException(m.type);
1572  }
1573  break;
1574  }
1575 
1576  case MSG_EDI_LEAVE_TERRN_EDITOR_REQUESTED:
1577  {
1578  try
1579  {
1580  if (App::sim_state->getEnum<SimState>() == SimState::EDITOR_MODE)
1581  {
1582  App::GetGameContext()->GetTerrain()->GetTerrainEditor()->WriteOutputFile();
1583  App::GetGameContext()->GetTerrain()->GetTerrainEditor()->ClearSelectedObject();
1584  App::sim_state->setVal((int)SimState::RUNNING);
1585  App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_INFO, Console::CONSOLE_SYSTEM_NOTICE,
1586  _L("Left terrain editing mode"));
1587  }
1588  }
1589  catch (...)
1590  {
1591  HandleMsgQueueException(m.type);
1592  }
1593  break;
1594  }
1595 
1596  case MSG_EDI_LOAD_BUNDLE_REQUESTED:
1597  {
1598  CacheEntryPtr* entry_ptr = static_cast<CacheEntryPtr*>(m.payload);
1599  try
1600  {
1601  App::GetCacheSystem()->LoadResource(*entry_ptr);
1602  TRIGGER_EVENT_ASYNC(SE_GENERIC_MODCACHE_ACTIVITY,
1603  /*ints*/ MODCACHEACTIVITY_BUNDLE_LOADED, (*entry_ptr)->number, 0, 0,
1604  /*strings*/ (*entry_ptr)->resource_group);
1605  }
1606  catch (...)
1607  {
1608  HandleMsgQueueException(m.type);
1609  }
1610  delete entry_ptr;
1611  break;
1612  }
1613 
1614  case MSG_EDI_RELOAD_BUNDLE_REQUESTED:
1615  {
1616  // To reload the bundle, it's resource group must be destroyed and re-created. All actors using it must be deleted.
1617  CacheEntryPtr* entry_ptr = static_cast<CacheEntryPtr*>(m.payload);
1618  try
1619  {
1620  bool all_clear = true;
1621  for (ActorPtr& actor: App::GetGameContext()->GetActorManager()->GetActors())
1622  {
1623  if (actor->GetGfxActor()->GetResourceGroup() == (*entry_ptr)->resource_group)
1624  {
1625  App::GetGameContext()->PushMessage(Message(MSG_SIM_DELETE_ACTOR_REQUESTED, static_cast<void*>(new ActorPtr(actor))));
1626  all_clear = false;
1627  }
1628  }
1629 
1630  if (all_clear)
1631  {
1632  // Nobody uses the RG anymore -> destroy and re-create it.
1633  App::GetCacheSystem()->ReLoadResource(*entry_ptr);
1634 
1635  TRIGGER_EVENT_ASYNC(SE_GENERIC_MODCACHE_ACTIVITY,
1636  /*ints*/ MODCACHEACTIVITY_BUNDLE_RELOADED, (*entry_ptr)->number, 0, 0,
1637  /*strings*/ (*entry_ptr)->resource_group);
1638 
1639  delete entry_ptr;
1640  }
1641  else
1642  {
1643  // Re-post the same message again so that it's message chain is executed later.
1644  App::GetGameContext()->PushMessage(m);
1645  failed_m = true;
1646  }
1647  }
1648  catch (...)
1649  {
1650  HandleMsgQueueException(m.type);
1651  }
1652  break;
1653  }
1654 
1655  case MSG_EDI_UNLOAD_BUNDLE_REQUESTED:
1656  {
1657  // Unloading bundle means the resource group will be destroyed. All actors using it must be deleted.
1658  CacheEntryPtr* entry_ptr = static_cast<CacheEntryPtr*>(m.payload);
1659  try
1660  {
1661  bool all_clear = true;
1662  for (ActorPtr& actor: App::GetGameContext()->GetActorManager()->GetActors())
1663  {
1664  if (actor->GetGfxActor()->GetResourceGroup() == (*entry_ptr)->resource_group)
1665  {
1666  App::GetGameContext()->PushMessage(Message(MSG_SIM_DELETE_ACTOR_REQUESTED, static_cast<void*>(new ActorPtr(actor))));
1667  all_clear = false;
1668  }
1669  }
1670 
1671  if (all_clear)
1672  {
1673  // Nobody uses the RG anymore -> destroy it.
1674  App::GetCacheSystem()->UnLoadResource(*entry_ptr);
1675 
1676  TRIGGER_EVENT_ASYNC(SE_GENERIC_MODCACHE_ACTIVITY,
1677  /*ints*/ MODCACHEACTIVITY_BUNDLE_UNLOADED, (*entry_ptr)->number, 0, 0);
1678 
1679  delete entry_ptr;
1680  }
1681  else
1682  {
1683  // Re-post the same message again so that it's message chain is executed later.
1684  App::GetGameContext()->PushMessage(m);
1685  failed_m = true;
1686  }
1687  }
1688  catch (...)
1689  {
1690  HandleMsgQueueException(m.type);
1691  }
1692 
1693  break;
1694  }
1695 
1696  case MSG_EDI_CREATE_PROJECT_REQUESTED:
1697  {
1698  CreateProjectRequest* request = static_cast<CreateProjectRequest*>(m.payload);
1699  try
1700  {
1701  App::GetCacheSystem()->CreateProject(request);
1702  }
1703  catch (...)
1704  {
1705  HandleMsgQueueException(m.type);
1706  }
1707  delete request;
1708  break;
1709  }
1710 
1711  case MSG_EDI_MODIFY_PROJECT_REQUESTED:
1712  {
1713  ModifyProjectRequest* request = static_cast<ModifyProjectRequest*>(m.payload);
1714  try
1715  {
1716  if (App::mp_state->getEnum<MpState>() != MpState::CONNECTED) // Do not allow tuning in multiplayer
1717  {
1718  App::GetCacheSystem()->ModifyProject(request);
1719  }
1720  }
1721  catch (...)
1722  {
1723  HandleMsgQueueException(m.type);
1724  }
1725  delete request;
1726  break;
1727  }
1728 
1729  case MSG_EDI_DELETE_PROJECT_REQUESTED:
1730  {
1731  CacheEntryPtr* entry_ptr = static_cast<CacheEntryPtr*>(m.payload);
1732  try
1733  {
1734  App::GetCacheSystem()->DeleteProject(*entry_ptr);
1735  }
1736  catch (...)
1737  {
1738  HandleMsgQueueException(m.type);
1739  }
1740  delete entry_ptr;
1741  break;
1742  }
1743 
1744  default:;
1745  }
1746 
1747  // Process chained messages
1748  if (!failed_m)
1749  {
1750  for (Message& chained_msg: m.chain)
1751  {
1752  App::GetGameContext()->PushMessage(chained_msg);
1753  }
1754  }
1755 
1756  } // Game events block
1757 
1758  // Check FPS limit
1759  if (App::gfx_fps_limit->getInt() > 0)
1760  {
1761  const float min_frame_time = 1.0f / Ogre::Math::Clamp(App::gfx_fps_limit->getInt(), 5, 240);
1762  float dt = std::chrono::duration<float>(std::chrono::high_resolution_clock::now() - start_time).count();
1763  while (dt < min_frame_time)
1764  {
1765  dt = std::chrono::duration<float>(std::chrono::high_resolution_clock::now() - start_time).count();
1766  }
1767  } // Check FPS limit block
1768 
1769  // Calculate delta time
1770  const auto now = std::chrono::high_resolution_clock::now();
1771  const float dt = std::chrono::duration<float>(now - start_time).count();
1772  start_time = now;
1773 
1774 #ifdef USE_SOCKETW
1775  // Process incoming network traffic
1776  if (App::mp_state->getEnum<MpState>() == MpState::CONNECTED)
1777  {
1778  std::vector<RoR::NetRecvPacket> packets = App::GetNetwork()->GetIncomingStreamData();
1779  if (!packets.empty())
1780  {
1781  RoR::ChatSystem::HandleStreamData(packets);
1782  if (App::app_state->getEnum<AppState>() == AppState::SIMULATION)
1783  {
1784  App::GetGameContext()->GetActorManager()->HandleActorStreamData(packets);
1785  App::GetGameContext()->GetCharacterFactory()->handleStreamData(packets); // Update characters last (or else beam coupling might fail)
1786  }
1787  }
1788  }
1789 #endif // USE_SOCKETW
1790 
1791  // Process input events
1792  if (dt != 0.f)
1793  {
1794  App::GetInputEngine()->Capture();
1795  App::GetInputEngine()->updateKeyBounces(dt);
1796 
1797  if (!App::GetGuiManager()->GameControls.IsInteractiveKeyBindingActive())
1798  {
1799  if (!App::GetGuiManager()->MainSelector.IsVisible() && !App::GetGuiManager()->MultiplayerSelector.IsVisible() &&
1800  !App::GetGuiManager()->GameSettings.IsVisible() && !App::GetGuiManager()->GameControls.IsVisible() &&
1801  !App::GetGuiManager()->GameAbout.IsVisible() && !App::GetGuiManager()->RepositorySelector.IsVisible())
1802  {
1803  App::GetGameContext()->HandleSavegameHotkeys();
1804  }
1805  App::GetGameContext()->UpdateGlobalInputEvents();
1806  App::GetGuiManager()->UpdateInputEvents(dt);
1807 
1808  if (App::app_state->getEnum<AppState>() == AppState::SIMULATION)
1809  {
1810  if (App::sim_state->getEnum<SimState>() == SimState::EDITOR_MODE)
1811  {
1812  App::GetGameContext()->UpdateSkyInputEvents(dt);
1813  App::GetGameContext()->GetTerrain()->GetTerrainEditor()->UpdateInputEvents(dt);
1814  }
1815  else
1816  {
1817  App::GetGameContext()->GetCharacterFactory()->Update(dt); // Character MUST be updated before CameraManager, otherwise camera position is always 1 frame behind the character position, causing stuttering.
1818  }
1819  App::GetCameraManager()->UpdateInputEvents(dt);
1820  App::GetOverlayWrapper()->update(dt);
1821  App::GetGameContext()->GetRepairMode().UpdateInputEvents(dt);
1822  App::GetGameContext()->GetActorManager()->UpdateInputEvents(dt);
1823  if (App::sim_state->getEnum<SimState>() == SimState::RUNNING)
1824  {
1825  if (App::GetCameraManager()->GetCurrentBehavior() != CameraManager::CAMERA_BEHAVIOR_FREE)
1826  {
1827  App::GetGameContext()->UpdateSimInputEvents(dt);
1828  App::GetGameContext()->UpdateSkyInputEvents(dt);
1829  if (App::GetGameContext()->GetPlayerActor() &&
1830  App::GetGameContext()->GetPlayerActor()->ar_state != ActorState::NETWORKED_OK) // we are in a vehicle
1831  {
1832  App::GetGameContext()->UpdateCommonInputEvents(dt);
1833  if (App::GetGameContext()->GetPlayerActor()->ar_state != ActorState::LOCAL_REPLAY)
1834  {
1835  if (App::GetGameContext()->GetPlayerActor()->ar_driveable == TRUCK)
1836  {
1837  App::GetGameContext()->UpdateTruckInputEvents(dt);
1838  }
1839  if (App::GetGameContext()->GetPlayerActor()->ar_driveable == AIRPLANE)
1840  {
1841  App::GetGameContext()->UpdateAirplaneInputEvents(dt);
1842  }
1843  if (App::GetGameContext()->GetPlayerActor()->ar_driveable == BOAT)
1844  {
1845  App::GetGameContext()->UpdateBoatInputEvents(dt);
1846  }
1847  }
1848  }
1849  }
1850  else // free cam mode
1851  {
1852  App::GetGameContext()->UpdateSkyInputEvents(dt);
1853  }
1854  }
1855  } // app state SIMULATION
1856  } // interactive key binding mode
1857  } // dt != 0
1858 
1859  // Update OutGauge device
1860  if (App::io_outgauge_mode->getInt() > 0)
1861  {
1862  App::GetOutGauge()->Update(dt, App::GetGameContext()->GetPlayerActor());
1863  }
1864 
1865  // Early GUI updates which require halted physics
1866  App::GetGuiManager()->NewImGuiFrame(dt);
1867  if (App::app_state->getEnum<AppState>() == AppState::SIMULATION)
1868  {
1869  App::GetGuiManager()->DrawSimulationGui(dt);
1870  for (ActorPtr& actor : App::GetGameContext()->GetActorManager()->GetActors())
1871  {
1872  actor->GetGfxActor()->UpdateDebugView();
1873  }
1874  if (App::GetGameContext()->GetPlayerActor())
1875  {
1876  App::GetGuiManager()->VehicleInfoTPanel.UpdateStats(dt, App::GetGameContext()->GetPlayerActor());
1877  if (App::GetGuiManager()->FrictionSettings.IsVisible())
1878  {
1879  App::GetGuiManager()->FrictionSettings.setActiveCol(App::GetGameContext()->GetPlayerActor()->ar_last_fuzzy_ground_model);
1880  }
1881  }
1882  }
1883 
1884 #ifdef USE_MUMBLE
1885  if (App::GetMumble())
1886  {
1887  App::GetMumble()->Update(); // 3d voice over network
1888  }
1889 #endif // USE_MUMBLE
1890 
1891 #ifdef USE_OPENAL
1892  App::GetSoundScriptManager()->update(dt); // update 3d audio listener position
1893 #endif // USE_OPENAL
1894 
1895 #ifdef USE_ANGELSCRIPT
1896  App::GetScriptEngine()->framestep(dt);
1897 #endif // USE_ANGELSCRIPT
1898 
1899  if (App::io_ffb_enabled->getBool() &&
1900  App::sim_state->getEnum<SimState>() == SimState::RUNNING)
1901  {
1902  App::GetAppContext()->GetForceFeedback().Update();
1903  }
1904 
1905  if (App::sim_state->getEnum<SimState>() == SimState::RUNNING)
1906  {
1907  App::GetGameContext()->GetSceneMouse().UpdateSimulation();
1908  }
1909 
1910  // Create snapshot of simulation state for Gfx/GUI updates
1911  if (App::sim_state->getEnum<SimState>() == SimState::RUNNING || // Obviously
1912  App::sim_state->getEnum<SimState>() == SimState::EDITOR_MODE) // Needed for character movement
1913  {
1914  App::GetGfxScene()->BufferSimulationData();
1915  }
1916 
1917  // Calculate elapsed simulation time (taking simulation speed and pause into account)
1918  float dt_sim = 0.f;
1919  if (App::sim_state->getEnum<SimState>() == SimState::RUNNING && !App::GetGameContext()->GetActorManager()->IsSimulationPaused())
1920  {
1921  dt_sim = dt * App::GetGameContext()->GetActorManager()->GetSimulationSpeed();
1922  }
1923 
1924  // Advance simulation
1925  if (App::sim_state->getEnum<SimState>() == SimState::RUNNING)
1926  {
1927  App::GetGameContext()->UpdateActors(); // *** Start new physics tasks. No reading from Actor N/B beyond this point.
1928  }
1929 
1930  // Scene and GUI updates
1931  if (App::app_state->getEnum<AppState>() == AppState::MAIN_MENU)
1932  {
1933  App::GetGuiManager()->DrawMainMenuGui();
1934  }
1935  else if (App::app_state->getEnum<AppState>() == AppState::SIMULATION)
1936  {
1937  App::GetGfxScene()->UpdateScene(dt_sim); // Draws GUI as well
1938  }
1939 
1940  // Render!
1941  Ogre::RenderWindow* render_window = RoR::App::GetAppContext()->GetRenderWindow();
1942  if (render_window->isClosed())
1943  {
1944  App::GetGameContext()->PushMessage(Message(MSG_APP_SHUTDOWN_REQUESTED));
1945  }
1946  else
1947  {
1948  App::GetAppContext()->GetOgreRoot()->renderOneFrame();
1949  if (!render_window->isActive() && render_window->isVisible())
1950  {
1951  render_window->update(); // update even when in background !
1952  }
1953  } // Render block
1954 
1955  App::GetGuiManager()->ApplyGuiCaptureKeyboard();
1956 
1957  } // End of main rendering/input loop
1958 
1959 #ifndef _DEBUG
1960  }
1961  catch (Ogre::Exception& e)
1962  {
1963  LOG(e.getFullDescription());
1964  ErrorUtils::ShowError(_L("An exception has occured!"), e.getFullDescription());
1965  }
1966  catch (std::runtime_error& e)
1967  {
1968  LOG(e.what());
1969  ErrorUtils::ShowError(_L("An exception (std::runtime_error) has occured!"), e.what());
1970  }
1971 #endif
1972 
1973  return 0;
1974 }
1975 
1976 #if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
1977 INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT )
1978 {
1979  return main(__argc, __argv);
1980 }
1981 #endif
1982 
1983 #ifdef __cplusplus
1984 }
1985 #endif
RoR::App::sys_user_dir
CVar * sys_user_dir
Definition: Application.cpp:163
RoR::MSG_EDI_MODIFY_PROJECT_REQUESTED
@ MSG_EDI_MODIFY_PROJECT_REQUESTED
Payload = RoR::UpdateProjectRequest* (owner)
Definition: Application.h:156
RoR::ScriptUnit
Represents a loaded script and all associated resources/handles.
Definition: ScriptEngine.h:69
ROR_ASSERT
#define ROR_ASSERT(_EXPR)
Definition: Application.h:40
GameContext.h
Game state manager and message-queue provider.
RoR::GUIManager::VehicleInfoTPanel
GUI::VehicleInfoTPanel VehicleInfoTPanel
Definition: GUIManager.h:118
RoR::CameraManager::UpdateInputEvents
void UpdateInputEvents(float dt)
Definition: CameraManager.cpp:242
RoR::ScriptEngine::unloadScript
void unloadScript(ScriptUnitID_t unique_id)
Unloads a script.
Definition: ScriptEngine.cpp:1033
RoR::App::CreateMumble
void CreateMumble()
Definition: Application.cpp:311
RoR::ActorLinkingRequest::alr_hook_group
int alr_hook_group
Definition: SimData.h:909
RoR::MSG_SIM_LOAD_TERRN_REQUESTED
@ MSG_SIM_LOAD_TERRN_REQUESTED
Definition: Application.h:118
RoR::ScriptEngine::setEventsEnabled
void setEventsEnabled(bool val)
Definition: ScriptEngine.h:213
RoR::GfxSkyMode::SANDSTORM
@ SANDSTORM
Sandstorm (fastest)
RoR::ASMANIP_SCRIPT_UNLOADING
@ ASMANIP_SCRIPT_UNLOADING
Triggered before unloading the script to let it clean up (important for missions).
Definition: ScriptEvents.h:76
GUI_MultiplayerClientList.h
RoR::App::CreateScriptEngine
void CreateScriptEngine()
Definition: Application.cpp:345
RoR::App::GetNetwork
Network * GetNetwork()
Definition: Application.cpp:287
RoR::MSG_SIM_REMOVE_FREEFORCE_REQUESTED
@ MSG_SIM_REMOVE_FREEFORCE_REQUESTED
Payload = RoR::FreeForceID_t* (owner)
Definition: Application.h:135
RoR::App::cli_force_cache_update
CVar * cli_force_cache_update
Definition: Application.cpp:184
RoR::LoadScriptRequest::lsr_filename
std::string lsr_filename
Load from resource (file). If buffer is supplied, use this as display name only.
Definition: ScriptEngine.h:92
RoR::App::GetContentManager
ContentManager * GetContentManager()
Definition: Application.cpp:270
RoR::App::GetSoundScriptManager
SoundScriptManager * GetSoundScriptManager()
Definition: Application.cpp:280
RoR::ContentManager::InitContentManager
void InitContentManager()
Definition: ContentManager.cpp:148
RoR::CacheSystem::UnLoadResource
void UnLoadResource(CacheEntryPtr &t)
Unloads associated bundle, destroying all spawned actors.
Definition: CacheSystem.cpp:1539
RoR::ActorManager::GetSimulationSpeed
float GetSimulationSpeed() const
Definition: ActorManager.h:92
RoR::GUI::TopMenubar::ai_presets_extern
rapidjson::Document ai_presets_extern
Externally provided presets (GitHub repo or local 'savegames/waypoints.json' file).
Definition: GUI_TopMenubar.h:105
RoR::MSG_GUI_SHOW_MESSAGE_BOX_REQUESTED
@ MSG_GUI_SHOW_MESSAGE_BOX_REQUESTED
Payload = MessageBoxConfig* (owner)
Definition: Application.h:142
RoR::GameContext::ExtractSceneTerrain
std::string ExtractSceneTerrain(std::string const &filename)
Returns terrain filename.
Definition: Savegame.cpp:87
RoR::GUI::MultiplayerSelector::SetVisible
void SetVisible(bool v)
Definition: GUI_MultiplayerSelector.cpp:392
RoR::TerrainEditor::UpdateInputEvents
void UpdateInputEvents(float dt)
Definition: TerrainEditor.cpp:43
RoR::App::diag_warning_texture
CVar * diag_warning_texture
Definition: Application.cpp:151
RoR::App::GetLanguageEngine
LanguageEngine * GetLanguageEngine()
Definition: Application.cpp:281
RoR::ScriptEventArgs
Args for eventCallbackEx() queued via MSG_SIM_SCRIPT_EVENT_TRIGGERED See descriptions at enum RoR::sc...
Definition: ScriptEvents.h:103
RoR::Network::Disconnect
void Disconnect()
Definition: Network.cpp:568
RoR::App::gfx_fov_internal
CVar * gfx_fov_internal
Definition: Application.cpp:240
RoR::CharacterFactory::handleStreamData
void handleStreamData(std::vector< RoR::NetRecvPacket > packet)
Definition: CharacterFactory.cpp:108
RoR::SE_ANGELSCRIPT_MANIPULATIONS
@ SE_ANGELSCRIPT_MANIPULATIONS
triggered when the user tries to dynamically use the scripting capabilities (prevent cheating) args: ...
Definition: ScriptEvents.h:54
RoR::App::CreateCameraManager
void CreateCameraManager()
Definition: Application.cpp:325
RoR::MSG_SIM_MODIFY_ACTOR_REQUESTED
@ MSG_SIM_MODIFY_ACTOR_REQUESTED
Payload = RoR::ActorModifyRequest* (owner)
Definition: Application.h:122
RoR::SoundScriptManager::setCamera
void setCamera(Ogre::Vector3 position, Ogre::Vector3 direction, Ogre::Vector3 up, Ogre::Vector3 velocity)
Definition: SoundScriptManager.cpp:324
RoR::App::diag_preset_vehicle
CVar * diag_preset_vehicle
Definition: Application.cpp:143
RoR::GfxScene::GetEnvMap
GfxEnvmap & GetEnvMap()
Definition: GfxScene.h:67
RoR::SceneMouse::DiscardVisuals
void DiscardVisuals()
Definition: SceneMouse.cpp:75
RoR::OverlayWrapper::update
void update(float dt)
Definition: OverlayWrapper.cpp:345
OverlayWrapper.h
RoR::GameContext::ModifyActor
void ModifyActor(ActorModifyRequest &rq)
Definition: GameContext.cpp:369
RoR::App::cli_resume_autosave
CVar * cli_resume_autosave
Definition: Application.cpp:185
RoR::MSG_EDI_RELOAD_BUNDLE_REQUESTED
@ MSG_EDI_RELOAD_BUNDLE_REQUESTED
Payload = RoR::CacheEntryPtr* (owner)
Definition: Application.h:153
RoR::Network::StartConnecting
bool StartConnecting()
Launches connecting on background.
Definition: Network.cpp:394
RoR::InputEngine::updateKeyBounces
void updateKeyBounces(float dt)
Definition: InputEngine.cpp:783
RoR::MSG_APP_REINIT_INPUT_REQUESTED
@ MSG_APP_REINIT_INPUT_REQUESTED
Definition: Application.h:95
RoR::TRUCK
@ TRUCK
its a truck (or other land vehicle)
Definition: SimData.h:93
RoR::MpState::CONNECTED
@ CONNECTED
RoR::CacheSystem::DeleteProject
void DeleteProject(CacheEntryPtr &entry)
Definition: CacheSystem.cpp:2057
RoR::GUIManager::FrictionSettings
GUI::FrictionSettings FrictionSettings
Definition: GUIManager.h:125
RoR::MSG_SIM_SCRIPT_CALLBACK_QUEUED
@ MSG_SIM_SCRIPT_CALLBACK_QUEUED
Payload = RoR::ScriptCallbackArgs* (owner)
Definition: Application.h:131
RoR::App::sys_scripts_dir
CVar * sys_scripts_dir
Definition: Application.cpp:172
RoR::EV_COMMON_ENTER_OR_EXIT_TRUCK
@ EV_COMMON_ENTER_OR_EXIT_TRUCK
enter or exit a truck
Definition: InputEngine.h:229
RoR::App::GetCameraManager
CameraManager * GetCameraManager()
Definition: Application.cpp:278
RoR::App::app_skip_main_menu
CVar * app_skip_main_menu
Definition: Application.cpp:82
GUI_VehicleInfoTPanel.h
RoR::GUI::MultiplayerSelector::DisplayRefreshFailed
void DisplayRefreshFailed(CurlFailInfo *failinfo)
Definition: GUI_MultiplayerSelector.cpp:406
GUI_MessageBox.h
Generic UI dialog (not modal). Invocable from scripting. Any number of buttons. Configurable to fire ...
RoR::App::GetGuiManager
GUIManager * GetGuiManager()
Definition: Application.cpp:272
RoR::MSG_EDI_CREATE_PROJECT_REQUESTED
@ MSG_EDI_CREATE_PROJECT_REQUESTED
Payload = RoR::CreateProjectRequest* (owner)
Definition: Application.h:155
RoR::GUI::MultiplayerSelector::UpdateServerlist
void UpdateServerlist(MpServerInfoVec *data)
Definition: GUI_MultiplayerSelector.cpp:418
RoR::DiscordRpc::UpdatePresence
void UpdatePresence()
Definition: DiscordRpc.cpp:60
RoR::GUIManager::ApplyGuiCaptureKeyboard
void ApplyGuiCaptureKeyboard()
Call after rendered frame to apply queued value.
Definition: GUIManager.cpp:122
RoR::GfxScene::BufferSimulationData
void BufferSimulationData()
Run this when simulation is halted.
Definition: GfxScene.cpp:288
RoR::ActorLinkingRequest
Estabilishing a physics linkage between 2 actors modifies a global linkage table and triggers immedia...
Definition: SimData.h:904
RoR::GUI::GameSettings::IsVisible
bool IsVisible() const
Definition: GUI_GameSettings.h:33
GUI_FrictionSettings.h
RoR::GUI::LoadingWindow::SetProgressNetConnect
void SetProgressNetConnect(const std::string &net_status)
Definition: GUI_LoadingWindow.cpp:73
RoR::MSG_EDI_UNLOAD_BUNDLE_REQUESTED
@ MSG_EDI_UNLOAD_BUNDLE_REQUESTED
Payload = RoR::CacheEntryPtr* (owner)
Definition: Application.h:154
RoR::HandleMsgQueueException
void HandleMsgQueueException(MsgType from)
Definition: Application.cpp:413
RoR::Actor::unmuteAllSounds
void unmuteAllSounds()
Definition: Actor.cpp:3781
RoR::AppState::MAIN_MENU
@ MAIN_MENU
RoR::ContentManager::ResourcePack::WALLPAPERS
static const ResourcePack WALLPAPERS
Definition: ContentManager.h:48
RoR::MSG_SIM_UNLOAD_TERRN_REQUESTED
@ MSG_SIM_UNLOAD_TERRN_REQUESTED
Definition: Application.h:120
ContentManager.h
RoR::GfxScene::RemoveGfxActor
void RemoveGfxActor(RoR::GfxActor *gfx_actor)
Definition: GfxScene.cpp:323
RoR::AppContext::GetRenderWindow
Ogre::RenderWindow * GetRenderWindow()
Definition: AppContext.h:67
RoR::App::cli_preset_vehicle
CVar * cli_preset_vehicle
Definition: Application.cpp:178
RoR::App::GetAppContext
AppContext * GetAppContext()
Definition: Application.cpp:269
RoR::Console::cVarSetupBuiltins
void cVarSetupBuiltins()
Create builtin vars and set defaults.
Definition: CVar.cpp:29
RoR::ActorState::LOCAL_REPLAY
@ LOCAL_REPLAY
RoR::MSG_GUI_CLOSE_SELECTOR_REQUESTED
@ MSG_GUI_CLOSE_SELECTOR_REQUESTED
Definition: Application.h:140
RoR::TokenType::INT
@ INT
format
Truck file format(technical spec)
RoR::ActorManager::AddFreeForce
void AddFreeForce(FreeForceRequest *rq)
Definition: ActorManager.cpp:1594
RoR::MSG_SIM_UNPAUSE_REQUESTED
@ MSG_SIM_UNPAUSE_REQUESTED
Definition: Application.h:117
RoR::DiscordRpc::Shutdown
void Shutdown()
Definition: DiscordRpc.cpp:90
RoR::ActorLinkingRequestType::HOOK_MOUSE_TOGGLE
@ HOOK_MOUSE_TOGGLE
GUIUtils.h
RoR::Network::GetIncomingStreamData
std::vector< NetRecvPacket > GetIncomingStreamData()
Definition: Network.cpp:678
RoR::AppState::PRINT_VERSION_EXIT
@ PRINT_VERSION_EXIT
RoR::MSG_NET_CONNECT_STARTED
@ MSG_NET_CONNECT_STARTED
Definition: Application.h:98
RoR::PeerOptionsRequest::por_uid
int por_uid
RoRnet unique user ID.
Definition: Network.h:107
RoR::MSG_GUI_DOWNLOAD_PROGRESS
@ MSG_GUI_DOWNLOAD_PROGRESS
Definition: Application.h:144
RoR::App::app_force_cache_update
CVar * app_force_cache_update
Definition: Application.cpp:89
RoR::CameraManager::CAMERA_BEHAVIOR_FREE
@ CAMERA_BEHAVIOR_FREE
Definition: CameraManager.h:52
RoR::GameContext::UpdateCommonInputEvents
void UpdateCommonInputEvents(float dt)
Definition: GameContext.cpp:1276
RoR::GUI::VehicleInfoTPanel::UpdateStats
void UpdateStats(float dt, ActorPtr actor)
Caution: touches live data, must be synced with sim. thread.
Definition: GUI_VehicleInfoTPanel.cpp:612
RoR::Actor::forceAllFlaresOff
void forceAllFlaresOff()
Definition: Actor.cpp:2987
RoR::ActorLinkingRequest::alr_type
ActorLinkingRequestType alr_type
Definition: SimData.h:907
RoR::App::mp_join_on_startup
CVar * mp_join_on_startup
Definition: Application.cpp:116
RoR::TRIGGER_EVENT_ASYNC
void TRIGGER_EVENT_ASYNC(scriptEvents type, int arg1, int arg2ex=0, int arg3ex=0, int arg4ex=0, std::string arg5ex="", std::string arg6ex="", std::string arg7ex="", std::string arg8ex="")
Asynchronously (via MSG_SIM_SCRIPT_EVENT_TRIGGERED) invoke script function eventCallbackEx(),...
Definition: ScriptEngine.h:51
RoR::ScriptEventArgs::arg4ex
int arg4ex
Definition: ScriptEvents.h:111
RoR::GUI::GameControls::IsVisible
bool IsVisible() const
Definition: GUI_GameControls.h:34
RoR::SimState::EDITOR_MODE
@ EDITOR_MODE
Hacky, but whatever... added by Ulteq, 2016.
RoR::Terrain::GetTerrainEditor
TerrainEditor * GetTerrainEditor()
Definition: Terrain.h:81
RoR::App::GetOverlayWrapper
OverlayWrapper * GetOverlayWrapper()
Definition: Application.cpp:271
RoR::SceneMouse::UpdateSimulation
void UpdateSimulation()
Definition: SceneMouse.cpp:199
CameraManager.h
RoR::ActorLinkingRequestType::HOOK_TOGGLE
@ HOOK_TOGGLE
RoR::LogFormat
void LogFormat(const char *format,...)
Improved logging utility. Uses fixed 2Kb buffer.
Definition: Application.cpp:427
RoR::App::cli_server_host
CVar * cli_server_host
Definition: Application.cpp:176
RoR::SE_TRUCK_MOUSE_GRAB
@ SE_TRUCK_MOUSE_GRAB
triggered when the user uses the mouse to interact with the actor, the argument refers to the actor I...
Definition: ScriptEvents.h:52
RoR::GfxScene::ClearScene
void ClearScene()
Definition: GfxScene.cpp:60
AppContext.h
System integration layer; inspired by OgreBites::ApplicationContext.
RoR::MSG_NET_REFRESH_SERVERLIST_FAILURE
@ MSG_NET_REFRESH_SERVERLIST_FAILURE
Payload = RoR::CurlFailInfo* (owner)
Definition: Application.h:107
Console.h
RoR::App::gfx_fov_external_default
CVar * gfx_fov_external_default
Definition: Application.cpp:239
RoR::Console::putMessage
void putMessage(MessageArea area, MessageType type, std::string const &msg, std::string icon="")
Definition: Console.cpp:103
RoR::GUIManager::GameControls
GUI::GameControls GameControls
Definition: GUIManager.h:127
RoR::ActorLinkingRequestType::HOOK_UNLOCK
@ HOOK_UNLOCK
RoR::SE_GENERIC_MODCACHE_ACTIVITY
@ SE_GENERIC_MODCACHE_ACTIVITY
Triggered when status of modcache changes, args: #1 type, #2 entry number, for other args see RoR::mo...
Definition: ScriptEvents.h:62
RoR::GameContext::TeleportPlayer
void TeleportPlayer(float x, float z)
Definition: GameContext.cpp:901
RoR::GameContext::UpdateActors
void UpdateActors()
Definition: GameContext.cpp:600
RoR::GUIManager::MpClientList
GUI::MpClientList MpClientList
Definition: GUIManager.h:124
RoR::MSG_NET_RECV_ERROR
@ MSG_NET_RECV_ERROR
Definition: Application.h:105
RoR::LoadScriptRequest::lsr_buffer
std::string lsr_buffer
Load from memory buffer.
Definition: ScriptEngine.h:93
GUI_DirectionArrow.h
Race direction arrow and text info (using OGRE Overlay)
RoR::ActorManager::GetActors
ActorPtrVec & GetActors()
Definition: ActorManager.h:118
RoR::CacheSystem::ModifyProject
void ModifyProject(ModifyProjectRequest *request)
Definition: CacheSystem.cpp:1848
RoR::App::io_ffb_enabled
CVar * io_ffb_enabled
Definition: Application.cpp:192
RoR::GUIManager::ChatBox
GUI::GameChatBox ChatBox
Definition: GUIManager.h:123
RoR::MSG_APP_LOAD_SCRIPT_REQUESTED
@ MSG_APP_LOAD_SCRIPT_REQUESTED
Payload = RoR::LoadScriptRequest* (owner)
Definition: Application.h:92
RoR::Actor::GetGfxActor
GfxActor * GetGfxActor()
Definition: Actor.h:275
RoR::GUI::TopMenubar::ai_waypoints
std::vector< ai_events > ai_waypoints
Definition: GUI_TopMenubar.h:68
RoR::GUIManager::GameSettings
GUI::GameSettings GameSettings
Definition: GUIManager.h:117
RoR::ActorManager::SyncWithSimThread
void SyncWithSimThread()
Definition: ActorManager.cpp:1224
RoR::GUIManager::DrawMainMenuGui
void DrawMainMenuGui()
Definition: GUIManager.cpp:414
RoR::SS_TRIG_MAIN_MENU
@ SS_TRIG_MAIN_MENU
Definition: SoundScriptManager.h:119
RoR::ActorLinkingRequestType::ROPE_TOGGLE
@ ROPE_TOGGLE
RoR::GUI::RepositorySelector::UpdateFiles
void UpdateFiles(ResourcesCollection *data)
Definition: GUI_RepositorySelector.cpp:1187
RoR::App::sim_state
CVar * sim_state
Definition: Application.cpp:96
Utils.h
RoR::CurlFailInfo
Definition: Network.h:47
RoR::GUI::MainSelector::Show
void Show(LoaderType type, std::string const &filter_guid="", CacheEntryPtr advertised_entry=nullptr)
Definition: GUI_MainSelector.cpp:65
RoR::ScriptEngine::framestep
void framestep(Ogre::Real dt)
Calls the script's framestep function to be able to use timed things inside the script.
Definition: ScriptEngine.cpp:403
Language.h
RoR::App::sys_savegames_dir
CVar * sys_savegames_dir
Definition: Application.cpp:170
RoR::MSG_NET_CONNECT_REQUESTED
@ MSG_NET_CONNECT_REQUESTED
Definition: Application.h:97
RefCountingObjectPtr< Actor >
RoR::GUIManager::DirectionArrow
GUI::DirectionArrow DirectionArrow
Definition: GUIManager.h:134
RoR::MSG_APP_DISPLAY_WINDOWED_REQUESTED
@ MSG_APP_DISPLAY_WINDOWED_REQUESTED
Definition: Application.h:88
RoR::SoundScriptManager::update
void update(float dt)
Definition: SoundScriptManager.cpp:308
RoR::MSG_NET_SERVER_KICK
@ MSG_NET_SERVER_KICK
Definition: Application.h:102
RoR::Console::CONSOLE_SYSTEM_ERROR
@ CONSOLE_SYSTEM_ERROR
Definition: Console.h:52
GUI_MultiplayerSelector.h
GUIManager.h
Actor.h
RoR::SimState::OFF
@ OFF
RoR::GUI::GameChatBox::AssignBuffer
void AssignBuffer(const std::string &buffer)
Definition: GUI_GameChatBox.h:50
RoR::App::GetScriptEngine
ScriptEngine * GetScriptEngine()
Definition: Application.cpp:282
RoR::GUIManager::LoadingWindow
GUI::LoadingWindow LoadingWindow
Definition: GUIManager.h:130
RoR::GfxScene::GetSceneManager
Ogre::SceneManager * GetSceneManager()
Definition: GfxScene.h:69
RoR::Console::CONSOLE_SYSTEM_NOTICE
@ CONSOLE_SYSTEM_NOTICE
Definition: Console.h:51
RoR::GUIManager::RepositorySelector
GUI::RepositorySelector RepositorySelector
Definition: GUIManager.h:128
RoR::ActorSpawnRequest
Definition: SimData.h:813
RoR::GameContext::GetRaceSystem
RaceSystem & GetRaceSystem()
Definition: GameContext.h:168
RoR::Console::purgeNetChatMessagesByUser
void purgeNetChatMessagesByUser(int user_id)
Definition: Console.cpp:58
RoR::MSG_APP_DISPLAY_FULLSCREEN_REQUESTED
@ MSG_APP_DISPLAY_FULLSCREEN_REQUESTED
Definition: Application.h:87
RoR::GfxEnvmap::SetupEnvMap
void SetupEnvMap()
Definition: EnvironmentMap.cpp:43
RoR::GUI::DirectionArrow::LoadOverlay
void LoadOverlay()
Must be called after meshes+overlays were loaded.
Definition: GUI_DirectionArrow.cpp:38
RoR::MSG_GUI_SHOW_CHATBOX_REQUESTED
@ MSG_GUI_SHOW_CHATBOX_REQUESTED
Description = message or server command to pre-fill in the chatbox (deleting whatever was there previ...
Definition: Application.h:147
RoR::AppContext::GetForceFeedback
RoR::ForceFeedback & GetForceFeedback()
Definition: AppContext.h:68
RoR::GameContext::SpawnActor
ActorPtr SpawnActor(ActorSpawnRequest &rq)
Definition: GameContext.cpp:193
RoR::MSG_NET_REFRESH_SERVERLIST_SUCCESS
@ MSG_NET_REFRESH_SERVERLIST_SUCCESS
Payload = GUI::MpServerInfoVec* (owner)
Definition: Application.h:106
RoR::App::mp_state
CVar * mp_state
Definition: Application.cpp:115
RoR::MSG_GUI_DOWNLOAD_FINISHED
@ MSG_GUI_DOWNLOAD_FINISHED
Definition: Application.h:145
RoR::GameContext::UpdateGlobalInputEvents
void UpdateGlobalInputEvents()
Definition: GameContext.cpp:939
RoR::ForceFeedback::Update
void Update()
Reads data from simulation.
Definition: ForceFeedback.cpp:105
RoR::GUIManager::NewImGuiFrame
void NewImGuiFrame(float dt)
Definition: GUIManager.cpp:318
RoR::LoadScriptRequest::lsr_category
ScriptCategory lsr_category
Definition: ScriptEngine.h:94
RoR::MSG_NET_FETCH_AI_PRESETS_FAILURE
@ MSG_NET_FETCH_AI_PRESETS_FAILURE
Description = message.
Definition: Application.h:112
RoR::App::CreateGuiManager
void CreateGuiManager()
Definition: Application.cpp:299
RoR::SceneMouse::InitializeVisuals
void InitializeVisuals()
Definition: SceneMouse.cpp:50
RoR::App::CreateGfxScene
void CreateGfxScene()
Definition: Application.cpp:331
RoR::GUI::MultiplayerSelector::IsVisible
bool IsVisible() const
Definition: GUI_MultiplayerSelector.h:63
RoR::CharacterFactory::Update
void Update(float dt)
Definition: CharacterFactory.cpp:80
RoR::GameContext::ChainMessage
void ChainMessage(Message m)
Add to last pushed message's chain.
Definition: GameContext.cpp:73
RoR::MSG_SIM_UNMUTE_NET_ACTOR_REQUESTED
@ MSG_SIM_UNMUTE_NET_ACTOR_REQUESTED
Payload = ActorPtr* (owner)
Definition: Application.h:129
RoR::TerrainEditor::ClearSelectedObject
void ClearSelectedObject()
Definition: TerrainEditor.cpp:306
RoR::GameContext::GetSceneMouse
SceneMouse & GetSceneMouse()
Definition: GameContext.h:170
RoR::InputEngine::Capture
void Capture()
Definition: InputEngine.cpp:631
RoR::CmdKeyInertiaConfig::LoadDefaultInertiaModels
void LoadDefaultInertiaModels()
Definition: CmdKeyInertia.cpp:138
RoR::GUIManager::MultiplayerSelector
GUI::MultiplayerSelector MultiplayerSelector
Definition: GUIManager.h:121
RoR::Str< 400 >
RoR::Collisions::getGroundModelByString
ground_model_t * getGroundModelByString(const Ogre::String name)
Definition: Collisions.cpp:365
RoR::ActorManager::RemoveFreeForce
void RemoveFreeForce(FreeForceID_t id)
Definition: ActorManager.cpp:1628
RoR::GUI::RepositorySelector::SetVisible
void SetVisible(bool visible)
Definition: GUI_RepositorySelector.cpp:1238
RoR::GUIManager::MenuWallpaper
Ogre::Overlay * MenuWallpaper
Definition: GUIManager.h:136
RoR::GUIManager::SetMouseCursorVisibility
void SetMouseCursorVisibility(MouseCursorVisibility visi)
Definition: GUIManager.cpp:290
RoR::ActorModifyRequest
Definition: SimData.h:853
RoR::GameContext::PopMessage
Message PopMessage()
Definition: GameContext.cpp:96
RoR::GfxScene::UpdateScene
void UpdateScene(float dt)
Definition: GfxScene.cpp:90
RoR::App::io_outgauge_mode
CVar * io_outgauge_mode
Definition: Application.cpp:200
RoR::ScriptUnit::scriptName
Ogre::String scriptName
Definition: ScriptEngine.h:83
RoR::GUIManager::UpdateInputEvents
void UpdateInputEvents(float dt)
Definition: GUIManager.cpp:483
RoR::PathCombine
std::string PathCombine(std::string a, std::string b)
Definition: PlatformUtils.h:48
RoR::MSG_SIM_SEAT_PLAYER_REQUESTED
@ MSG_SIM_SEAT_PLAYER_REQUESTED
Payload = RoR::ActorPtr (owner) | nullptr.
Definition: Application.h:124
RoR::GfxScene::RegisterGfxActor
void RegisterGfxActor(RoR::GfxActor *gfx_actor)
Definition: GfxScene.cpp:283
GUI_LoadingWindow.h
CacheSystem.h
A database of user-installed content alias 'mods' (vehicles, terrains...)
RoR::MSG_NET_ADD_PEEROPTIONS_REQUESTED
@ MSG_NET_ADD_PEEROPTIONS_REQUESTED
Payload = RoR::PeerOptionsRequest* (owner)
Definition: Application.h:113
RoR::MODCACHEACTIVITY_BUNDLE_UNLOADED
@ MODCACHEACTIVITY_BUNDLE_UNLOADED
Args: #1 type, #2 entry number.
Definition: ScriptEvents.h:98
RoR::App::gfx_fps_limit
CVar * gfx_fps_limit
Definition: Application.cpp:244
RoR::MSG_APP_MODCACHE_PURGE_REQUESTED
@ MSG_APP_MODCACHE_PURGE_REQUESTED
Definition: Application.h:91
RoR::ActorManager::HandleActorStreamData
void HandleActorStreamData(std::vector< RoR::NetRecvPacket > packet)
Definition: ActorManager.cpp:353
RoR::ContentManager::ResourcePack::FLAGS
static const ResourcePack FLAGS
Definition: ContentManager.h:55
ErrorUtils.h
RoR::GameContext::ChangePlayerActor
void ChangePlayerActor(ActorPtr actor)
Definition: GameContext.cpp:487
BITMASK_IS_1
#define BITMASK_IS_1(VAR, FLAGS)
Definition: BitFlags.h:14
GUI_MainSelector.h
RoR::GUI::RepositorySelector::IsVisible
bool IsVisible() const
Definition: GUI_RepositorySelector.h:97
RoR::GUIManager::CollisionsDebug
GUI::CollisionsDebug CollisionsDebug
Definition: GUIManager.h:114
RoR::MSG_GUI_MP_CLIENTS_REFRESH
@ MSG_GUI_MP_CLIENTS_REFRESH
Definition: Application.h:141
RoR::ContentManager::ResourcePack::SCRIPTS
static const ResourcePack SCRIPTS
Definition: ContentManager.h:68
ScriptEngine.h
RoR::GameContext::DeleteActor
void DeleteActor(ActorPtr actor)
Definition: GameContext.cpp:438
RoR::App::sys_thumbnails_dir
CVar * sys_thumbnails_dir
Definition: Application.cpp:166
RoR::ScriptUnit::scriptCategory
ScriptCategory scriptCategory
Definition: ScriptEngine.h:75
RoR::MODCACHEACTIVITY_BUNDLE_RELOADED
@ MODCACHEACTIVITY_BUNDLE_RELOADED
Args: #1 type, #2 entry number, –, –, #5 rg name.
Definition: ScriptEvents.h:97
RoR::GUI::GameChatBox::SetVisible
void SetVisible(bool v)
Definition: GUI_GameChatBox.h:45
RoR::GameContext::PushMessage
void PushMessage(Message m)
Doesn't guarantee order! Use ChainMessage() if order matters.
Definition: GameContext.cpp:66
RoR::App::app_state
CVar * app_state
Definition: Application.cpp:79
ChatSystem.h
RoR::Str::ToCStr
const char * ToCStr() const
Definition: Str.h:46
RoR::GUI::RepositorySelector::DownloadFinished
void DownloadFinished()
Definition: GUI_RepositorySelector.cpp:1221
RoR::GUI::ResourcesCollection
Definition: GUI_RepositorySelector.h:79
RoR::Console::saveConfig
void saveConfig()
Definition: AppConfig.cpp:407
RoR::App::sim_terrain_name
CVar * sim_terrain_name
Definition: Application.cpp:97
RoR::MSG_NET_REMOVE_PEEROPTIONS_REQUESTED
@ MSG_NET_REMOVE_PEEROPTIONS_REQUESTED
Payload = RoR::PeerOptionsRequest* (owner)
Definition: Application.h:114
RoR::CameraManager::ResetAllBehaviors
void ResetAllBehaviors()
Definition: CameraManager.cpp:529
RoR::App::DestroyOverlayWrapper
void DestroyOverlayWrapper()
Definition: Application.cpp:354
RoR::FreeForceID_t
int FreeForceID_t
Unique sequentially generated ID of FreeForce; use ActorManager::GetFreeForceNextId().
Definition: ForwardDeclarations.h:67
RoR::GUI::LoadingWindow::SetVisible
void SetVisible(bool v)
Definition: GUI_LoadingWindow.h:41
RoR::PeerOptionsRequest::por_peeropts
BitMask_t por_peeropts
See RoRnet::PeerOptions.
Definition: Network.h:108
RoR::Terrain::GetCollisions
Collisions * GetCollisions()
Definition: Terrain.h:82
RoR::GUI::LoadingWindow::SetProgress
void SetProgress(int _percent, const std::string &_text="", bool render_frame=true)
Definition: GUI_LoadingWindow.cpp:33
RoR::GameContext::GetCharacterFactory
CharacterFactory * GetCharacterFactory()
Definition: GameContext.h:150
RoR::ScriptEngine::envokeCallback
void envokeCallback(int functionId, eventsource_t *source, NodeNum_t nodenum=NODENUM_INVALID, int type=0)
Definition: ScriptEngine.cpp:462
RoR::App::sys_cache_dir
CVar * sys_cache_dir
Definition: Application.cpp:165
RoR::CreateFolder
void CreateFolder(const char *path)
Path must be UTF-8 encoded.
Definition: PlatformUtils.cpp:175
RoR::Actor::hookToggle
void hookToggle(int group=-1, ActorLinkingRequestType mode=ActorLinkingRequestType::HOOK_TOGGLE, NodeNum_t mousenode=NODENUM_INVALID, ActorInstanceID_t forceunlock_filter=ACTORINSTANCEID_INVALID)
Definition: Actor.cpp:3580
GfxScene.h
RoR::GUI::TopMenubar::ai_presets_extern_fetching
bool ai_presets_extern_fetching
True if the (down)load of 'extern' waypoints is in progress.
Definition: GUI_TopMenubar.h:106
PlatformUtils.h
Platform-specific utilities. We use narrow UTF-8 encoded strings as paths. Inspired by http://utf8eve...
RoR::MSG_NET_REFRESH_REPOLIST_FAILURE
@ MSG_NET_REFRESH_REPOLIST_FAILURE
Payload = RoR::CurlFailInfo* (owner)
Definition: Application.h:110
RoR::ChatSystem::SendStreamSetup
void SendStreamSetup()
Definition: ChatSystem.cpp:35
RoR::MSG_GUI_OPEN_SELECTOR_REQUESTED
@ MSG_GUI_OPEN_SELECTOR_REQUESTED
Payload = LoaderType* (owner), Description = GUID | empty.
Definition: Application.h:139
RoR::App::cli_custom_scripts
CVar * cli_custom_scripts
Definition: Application.cpp:186
SOUND_START
#define SOUND_START(_ACTOR_, _TRIG_)
Definition: SoundScriptManager.h:35
RoR::CacheValidity::UNKNOWN
@ UNKNOWN
RoR::MSG_SIM_HIDE_NET_ACTOR_REQUESTED
@ MSG_SIM_HIDE_NET_ACTOR_REQUESTED
Payload = ActorPtr* (owner)
Definition: Application.h:126
RoR::Network::AddPeerOptions
void AddPeerOptions(PeerOptionsRequest *rq)
Definition: Network.cpp:800
RoR::SoundScriptManager::createInstance
SoundScriptInstancePtr createInstance(Ogre::String templatename, int actor_id, int soundLinkType=SL_DEFAULT, int soundLinkItemId=-1)
Definition: SoundScriptManager.cpp:356
RoR::LoaderType
LoaderType
< Search mode for ModCache::Query() & Operation mode for GUI::MainSelector
Definition: Application.h:306
RoR::MSG_GUI_REFRESH_TUNING_MENU_REQUESTED
@ MSG_GUI_REFRESH_TUNING_MENU_REQUESTED
Definition: Application.h:146
RoR::ActorLinkingRequest::alr_rope_group
int alr_rope_group
Definition: SimData.h:914
RoR::MSG_SIM_ADD_FREEFORCE_REQUESTED
@ MSG_SIM_ADD_FREEFORCE_REQUESTED
Payload = RoR::FreeForceRequest* (owner)
Definition: Application.h:133
RoR::LoadScriptRequest::lsr_associated_actor
ActorInstanceID_t lsr_associated_actor
For ScriptCategory::ACTOR.
Definition: ScriptEngine.h:95
DiscordRpc.h
RoR::SimState::PAUSED
@ PAUSED
Application.h
Central state/object manager and communications hub.
RoR::App::GetConsole
Console * GetConsole()
Definition: Application.cpp:273
RoR::MSG_NET_OPEN_RESOURCE_SUCCESS
@ MSG_NET_OPEN_RESOURCE_SUCCESS
Payload = GUI::ResourcesCollection* (owner)
Definition: Application.h:109
SoundScriptManager.h
RoR::MSG_APP_MODCACHE_LOAD_REQUESTED
@ MSG_APP_MODCACHE_LOAD_REQUESTED
Definition: Application.h:89
RoR::Message::payload
void * payload
Definition: GameContext.h:59
RoR::App::GetGameContext
GameContext * GetGameContext()
Definition: Application.cpp:283
RoR::App::CreateThreadPool
void CreateThreadPool()
Definition: Application.cpp:319
RoR::ground_model_t::name
char name[256]
Definition: SimData.h:744
RoR::ScriptCallbackArgs
Definition: ScriptEngine.h:98
RoR::MSG_APP_SCREENSHOT_REQUESTED
@ MSG_APP_SCREENSHOT_REQUESTED
Definition: Application.h:86
RoR::App::gfx_fov_internal_default
CVar * gfx_fov_internal_default
Definition: Application.cpp:241
RoR::ContentManager::ResourcePack::ICONS
static const ResourcePack ICONS
Definition: ContentManager.h:58
RoR::AIRPLANE
@ AIRPLANE
its an airplane
Definition: SimData.h:94
RoR::GUI::RepositorySelector::UpdateResources
void UpdateResources(ResourcesCollection *data)
Definition: GUI_RepositorySelector.cpp:1166
RoR::MSG_NET_REFRESH_REPOLIST_SUCCESS
@ MSG_NET_REFRESH_REPOLIST_SUCCESS
Payload = GUI::ResourcesCollection* (owner)
Definition: Application.h:108
RoR::RaceSystem::ResetRaceUI
void ResetRaceUI()
Definition: RaceSystem.cpp:64
RoR::AppState::SIMULATION
@ SIMULATION
RoR::Message::chain
std::vector< Message > chain
Posted after the message is processed.
Definition: GameContext.h:60
RoR::ActorSB::simbuf_actor_state
ActorState simbuf_actor_state
Definition: SimBuffers.h:115
RoR::ScriptEngine::triggerEvent
void triggerEvent(scriptEvents eventnum, int arg1=0, int arg2ex=0, int arg3ex=0, int arg4ex=0, std::string arg5ex="", std::string arg6ex="", std::string arg7ex="", std::string arg8ex="")
triggers an event; Not to be used by the end-user.
Definition: ScriptEngine.cpp:781
RoRVersion.h
RoR::GUI::TopMenubar::RefreshTuningMenu
void RefreshTuningMenu()
Definition: GUI_TopMenubar.cpp:2487
RoR::eventsource_t::es_script_handler
int es_script_handler
AngelScript function ID.
Definition: Collisions.h:45
RoR::LoadScriptRequest
Definition: ScriptEngine.h:90
RoR::GUI::GameMainMenu::SetVisible
void SetVisible(bool v)
Definition: GUI_GameMainMenu.h:43
RoR::AppContext::CaptureScreenshot
void CaptureScreenshot()
Definition: AppContext.cpp:395
RoR::CharacterFactory::DeleteAllCharacters
void DeleteAllCharacters()
Definition: CharacterFactory.cpp:101
RoR::AppState::SHUTDOWN
@ SHUTDOWN
RoR::App::gfx_sky_mode
CVar * gfx_sky_mode
Definition: Application.cpp:219
RoR::TerrainEditor::WriteOutputFile
void WriteOutputFile()
Definition: TerrainEditor.cpp:234
RoR::ScriptEventArgs::arg7ex
std::string arg7ex
Definition: ScriptEvents.h:114
RoR::GUIManager::DrawSimulationGui
void DrawSimulationGui(float dt)
Touches live data; must be called in sync with sim. thread.
Definition: GUIManager.cpp:154
RoR::MSG_SIM_TELEPORT_PLAYER_REQUESTED
@ MSG_SIM_TELEPORT_PLAYER_REQUESTED
Payload = Ogre::Vector3* (owner)
Definition: Application.h:125
RoR::Message::description
std::string description
Definition: GameContext.h:58
RoR::Actor::toggleSlideNodeLock
void toggleSlideNodeLock()
Definition: ActorSlideNode.cpp:34
RoR::App::CreateOverlayWrapper
void CreateOverlayWrapper()
Definition: Application.cpp:293
_LC
#define _LC(ctx, str)
Definition: Language.h:42
RoR::GUIManager::TopMenubar
GUI::TopMenubar TopMenubar
Definition: GUIManager.h:131
RoR::GUI::TopMenubar::RefreshAiPresets
void RefreshAiPresets()
Refresh the list of presets, used for display. Needs to be called when terrain is loaded.
Definition: GUI_TopMenubar.cpp:2466
RoR::AppState::PRINT_HELP_EXIT
@ PRINT_HELP_EXIT
RoR::CacheSystem::CreateProject
CacheEntryPtr CreateProject(CreateProjectRequest *request)
Creates subdirectory in 'My Games\Rigs of Rods\projects', pre-populates it with files and adds modcac...
Definition: CacheSystem.cpp:1675
RoR::MSG_EDI_ENTER_TERRN_EDITOR_REQUESTED
@ MSG_EDI_ENTER_TERRN_EDITOR_REQUESTED
Definition: Application.h:150
RoR::MSG_EDI_LOAD_BUNDLE_REQUESTED
@ MSG_EDI_LOAD_BUNDLE_REQUESTED
Payload = RoR::CacheEntryPtr* (owner)
Definition: Application.h:152
RoR::GUIManager::ShowMessageBox
void ShowMessageBox(const char *title, const char *text, bool allow_close=true, const char *btn1_text="OK", const char *btn2_text=nullptr)
Definition: GUIManager.cpp:454
RoR::App::cli_server_port
CVar * cli_server_port
Definition: Application.cpp:177
RoR::App::sys_config_dir
CVar * sys_config_dir
Definition: Application.cpp:164
RoR::ChatSystem::HandleStreamData
void HandleStreamData(std::vector< RoR::NetRecvPacket > packet_buffer)
Definition: ChatSystem.cpp:71
RoR::AppContext::SetUpLogging
void SetUpLogging()
Definition: AppContext.cpp:508
RoR::ModifyProjectRequest
Definition: CacheSystem.h:265
RoR::MSG_NET_CONNECT_SUCCESS
@ MSG_NET_CONNECT_SUCCESS
Definition: Application.h:100
RoR::CreateProjectRequest
Creates subdirectory in 'My Games\Rigs of Rods\projects', pre-populates it with files and adds modcac...
Definition: CacheSystem.h:219
RoR::LT_Terrain
@ LT_Terrain
Definition: Application.h:309
RoR::ScriptEventArgs::arg5ex
std::string arg5ex
Definition: ScriptEvents.h:112
RoR::App::cli_preset_terrain
CVar * cli_preset_terrain
Definition: Application.cpp:180
RoR::AppContext::SetUpThreads
void SetUpThreads()
Definition: AppContext.cpp:618
RoR::App::GetDiscordRpc
DiscordRpc * GetDiscordRpc()
Definition: Application.cpp:285
GUI_RepositorySelector.h
RoR::GUI::FrictionSettings::setActiveCol
void setActiveCol(const ground_model_t *gm)
Definition: GUI_FrictionSettings.h:56
RoR::ScriptEngine::loadScript
ScriptUnitID_t loadScript(Ogre::String scriptname, ScriptCategory category=ScriptCategory::TERRAIN, ActorPtr associatedActor=nullptr, std::string buffer="")
Loads a script.
Definition: ScriptEngine.cpp:828
RoR::MSG_NET_FETCH_AI_PRESETS_SUCCESS
@ MSG_NET_FETCH_AI_PRESETS_SUCCESS
Description = JSON string.
Definition: Application.h:111
RoR::AppContext::ActivateFullscreen
void ActivateFullscreen(bool val)
Definition: AppContext.cpp:442
Skidmark.h
RoR::Actor::ar_muted_by_peeropt
bool ar_muted_by_peeropt
Muted by user in multiplayer (see RoRnet::PEEROPT_MUTE_ACTORS).
Definition: Actor.h:457
RoR::AppContext::SetUpObsoleteConfMarker
void SetUpObsoleteConfMarker()
Definition: AppContext.cpp:586
RoR::App::GetCacheSystem
CacheSystem * GetCacheSystem()
Definition: Application.cpp:275
RoR::ContentManager::AddResourcePack
void AddResourcePack(ResourcePack const &resource_pack, std::string const &override_rgn="")
Loads resources if not already loaded.
Definition: ContentManager.cpp:99
RoR::CacheValidity::NEEDS_REBUILD
@ NEEDS_REBUILD
RoR::GameContext::UpdateAirplaneInputEvents
void UpdateAirplaneInputEvents(float dt)
Definition: GameContext.cpp:1558
RoR::GUI::MpServerInfoVec
std::vector< MpServerInfo > MpServerInfoVec
Definition: GUI_MultiplayerSelector.h:52
RoR::CacheValidity::NEEDS_UPDATE
@ NEEDS_UPDATE
RoR::App::audio_menu_music
CVar * audio_menu_music
Definition: Application.cpp:212
RoR::FreeForceRequest
Common for ADD and MODIFY requests; tailored for use with AngelScript thru GameScript::pushMessage().
Definition: SimData.h:785
RoR::Network::RemovePeerOptions
void RemovePeerOptions(PeerOptionsRequest *rq)
Definition: Network.cpp:817
RoR::App::diag_preset_veh_config
CVar * diag_preset_veh_config
Definition: Application.cpp:144
RoR::ActorLinkingRequest::alr_tie_group
int alr_tie_group
Definition: SimData.h:912
RoR::OutGauge::Close
void Close()
Definition: OutGauge.cpp:43
RoR::GfxActor::SetCastShadows
void SetCastShadows(bool value)
Definition: GfxActor.cpp:3333
RoR::Console::showCommandLineVersion
void showCommandLineVersion()
Definition: AppCommandLine.cpp:181
RoR::GUI::MessageBoxConfig
Definition: GUI_MessageBox.h:50
RoR::ContentManager::ResourcePack::OGRE_CORE
static const ResourcePack OGRE_CORE
Definition: ContentManager.h:47
RoR::App::mp_server_port
CVar * mp_server_port
Definition: Application.cpp:122
RoR::ScriptCallbackArgs::eventsource
eventsource_t * eventsource
Definition: ScriptEngine.h:102
RoR::MSG_EDI_DELETE_PROJECT_REQUESTED
@ MSG_EDI_DELETE_PROJECT_REQUESTED
Payload = RoR::CacheEntryPtr* (owner)
Definition: Application.h:157
RoR::CacheSystem::LoadResource
void LoadResource(CacheEntryPtr &t)
Loads the associated resource bundle if not already done.
Definition: CacheSystem.cpp:1440
RoR::PeerOptionsRequest
Payload of MSG_NET_{ADD/REMOVE}_PEEROPTIONS_REQUESTED.
Definition: Network.h:105
RoR::MSG_SIM_ACTOR_LINKING_REQUESTED
@ MSG_SIM_ACTOR_LINKING_REQUESTED
Payload = RoR::ActorLinkingRequest* (owner)
Definition: Application.h:132
RoR::Message
Unified game event system - all requests and state changes are reported using a message.
Definition: GameContext.h:51
RoR::Console::loadConfig
void loadConfig()
Definition: AppConfig.cpp:342
RoR::App::mp_server_host
CVar * mp_server_host
Definition: Application.cpp:121
RoR::ScriptEventArgs::arg8ex
std::string arg8ex
Definition: ScriptEvents.h:115
RoR::ContentManager::LoadGameplayResources
void LoadGameplayResources()
Checks GVar settings and loads required resources.
Definition: ContentManager.cpp:402
RoR::Actor::setSmokeEnabled
void setSmokeEnabled(bool enabled)
Writes info to console/notify area.
Definition: Actor.h:167
RoR::GameContext::UnloadTerrain
void UnloadTerrain()
Definition: GameContext.cpp:179
RoR::CVar::setVal
void setVal(T val)
Definition: CVar.h:72
RoR::ScriptEngine::getScriptUnit
ScriptUnit & getScriptUnit(ScriptUnitID_t unique_id)
Definition: ScriptEngine.cpp:1069
_L
#define _L
Definition: ErrorUtils.cpp:34
RoR::MSG_GUI_OPEN_MENU_REQUESTED
@ MSG_GUI_OPEN_MENU_REQUESTED
Definition: Application.h:137
RoR::GameContext::LoadScene
void LoadScene(std::string const &filename)
Matching terrain must be already loaded.
Definition: Savegame.cpp:64
RoR::ContentManager::InitModCache
void InitModCache(CacheValidity validity)
Definition: ContentManager.cpp:251
OutGauge.h
RoR::Actor::tieToggle
void tieToggle(int group=-1, ActorLinkingRequestType mode=ActorLinkingRequestType::TIE_TOGGLE, ActorInstanceID_t forceunlock_filter=ACTORINSTANCEID_INVALID)
Definition: Actor.cpp:3386
RoR::GUI::MpClientList::UpdateClients
void UpdateClients()
Definition: GUI_MultiplayerClientList.cpp:45
RoR::Actor::ropeToggle
void ropeToggle(int group=-1, ActorLinkingRequestType mode=ActorLinkingRequestType::ROPE_TOGGLE, ActorInstanceID_t forceunlock_filter=ACTORINSTANCEID_INVALID)
Definition: Actor.cpp:3503
RoR::ScriptEventArgs::type
scriptEvents type
Definition: ScriptEvents.h:106
RoR::ActorManager::UpdateInputEvents
void UpdateInputEvents(float dt)
Definition: ActorManager.cpp:1333
RoR::Console::regBuiltinCommands
void regBuiltinCommands()
Register builtin commands.
Definition: ConsoleCmd.cpp:650
RoR::GUIManager::GameAbout
GUI::GameAbout GameAbout
Definition: GUIManager.h:116
RoR::MSG_EDI_LEAVE_TERRN_EDITOR_REQUESTED
@ MSG_EDI_LEAVE_TERRN_EDITOR_REQUESTED
Definition: Application.h:151
RoR::GUI::CollisionsDebug::CleanUp
void CleanUp()
Definition: GUI_CollisionsDebug.cpp:396
RoR::App::sys_projects_dir
CVar * sys_projects_dir
Definition: Application.cpp:173
RoR::MSG_SIM_SPAWN_ACTOR_REQUESTED
@ MSG_SIM_SPAWN_ACTOR_REQUESTED
Payload = RoR::ActorSpawnRequest* (owner)
Definition: Application.h:121
RoR::MSG_APP_MODCACHE_UPDATE_REQUESTED
@ MSG_APP_MODCACHE_UPDATE_REQUESTED
Definition: Application.h:90
RoR::App::GetInputEngine
InputEngine * GetInputEngine()
Definition: Application.cpp:274
RoR::ActorManager::ModifyFreeForce
void ModifyFreeForce(FreeForceRequest *rq)
Definition: ActorManager.cpp:1611
RoR::CacheSystem::ReLoadResource
void ReLoadResource(CacheEntryPtr &t)
Forces reloading the associated bundle.
Definition: CacheSystem.cpp:1526
RoR::App::cli_preset_veh_config
CVar * cli_preset_veh_config
Definition: Application.cpp:179
RoR::ground_model_t
Surface friction properties.
Definition: SimData.h:720
RoR::ScriptEventArgs::arg2ex
int arg2ex
Definition: ScriptEvents.h:109
RoR::EV_COMMON_ENTER_CHATMODE
@ EV_COMMON_ENTER_CHATMODE
enter the chat mode
Definition: InputEngine.h:228
RoR::ActorPtr
RefCountingObjectPtr< Actor > ActorPtr
Definition: ForwardDeclarations.h:219
RoR::GUI::GameAbout::IsVisible
bool IsVisible() const
Definition: GUI_GameAbout.h:35
RoR::ActorLinkingRequest::alr_actor_instance_id
ActorInstanceID_t alr_actor_instance_id
Definition: SimData.h:906
RoR::MSG_NET_CONNECT_FAILURE
@ MSG_NET_CONNECT_FAILURE
Definition: Application.h:101
RoR::GUI::MainSelector::Close
void Close()
Definition: GUI_MainSelector.cpp:592
RoR::MSG_SIM_DELETE_ACTOR_REQUESTED
@ MSG_SIM_DELETE_ACTOR_REQUESTED
Payload = RoR::ActorPtr* (owner)
Definition: Application.h:123
RoR::GameContext::UpdateSimInputEvents
void UpdateSimInputEvents(float dt)
Definition: GameContext.cpp:1054
RoR::GameContext::UpdateBoatInputEvents
void UpdateBoatInputEvents(float dt)
Definition: GameContext.cpp:1746
RoR::DiscordRpc::Init
void Init()
Definition: DiscordRpc.cpp:44
RoR::GUI::TopMenubar::ai_presets_extern_error
std::string ai_presets_extern_error
Error message from the (down)load of 'extern' waypoints.
Definition: GUI_TopMenubar.h:107
RoR::MSG_APP_SCRIPT_THREAD_STATUS
@ MSG_APP_SCRIPT_THREAD_STATUS
Payload = RoR::ScriptEventArgs* (owner)
Definition: Application.h:94
RoRnet::PEEROPT_HIDE_ACTORS
@ PEEROPT_HIDE_ACTORS
Spawn actors hidden and immediatelly hide existing actors.
Definition: RoRnet.h:131
RoR::App::GetOutGauge
OutGauge * GetOutGauge()
Definition: Application.cpp:284
RoR::App::gfx_fov_external
CVar * gfx_fov_external
Definition: Application.cpp:238
RoR::MSG_EDI_MODIFY_GROUNDMODEL_REQUESTED
@ MSG_EDI_MODIFY_GROUNDMODEL_REQUESTED
Payload = RoR::ground_model_t* (weak)
Definition: Application.h:149
RoR::AppContext::GetOgreRoot
Ogre::Root * GetOgreRoot()
Definition: AppContext.h:65
Terrain.h
RoR::App::DestroyInputEngine
void DestroyInputEngine()
Definition: Application.cpp:360
RoR::ActorLinkingRequest::alr_hook_mousenode
NodeNum_t alr_hook_mousenode
Definition: SimData.h:910
RoR::SimState::RUNNING
@ RUNNING
RoR::ActorState::NETWORKED_HIDDEN
@ NETWORKED_HIDDEN
not simulated, not updated (remote)
InputEngine.h
Handles controller inputs from player. Defines input events and binding mechanism,...
RoR::GameContext::SaveScene
void SaveScene(std::string const &filename)
Definition: Savegame.cpp:70
RoR::GUIManager::MainSelector
GUI::MainSelector MainSelector
Definition: GUIManager.h:122
RoR::Console::showCommandLineUsage
void showCommandLineUsage()
Definition: AppCommandLine.cpp:162
RoR::MSG_SIM_UNHIDE_NET_ACTOR_REQUESTED
@ MSG_SIM_UNHIDE_NET_ACTOR_REQUESTED
Payload = ActorPtr* (owner)
Definition: Application.h:127
RoR::ActorLinkingRequestType::SLIDENODE_TOGGLE
@ SLIDENODE_TOGGLE
RoR::MSG_APP_UNLOAD_SCRIPT_REQUESTED
@ MSG_APP_UNLOAD_SCRIPT_REQUESTED
Payload = RoR::ScriptUnitId_t* (owner)
Definition: Application.h:93
RoRnet::PEEROPT_MUTE_CHAT
@ PEEROPT_MUTE_CHAT
CHAT and PRIVCHAT messages will not be allowed through.
Definition: RoRnet.h:129
RoR::GUIManager::SetUpMenuWallpaper
void SetUpMenuWallpaper()
Definition: GUIManager.cpp:237
RoR::ActorManager::GetInertiaConfig
RoR::CmdKeyInertiaConfig & GetInertiaConfig()
Definition: ActorManager.h:96
RoRnet::PEEROPT_MUTE_ACTORS
@ PEEROPT_MUTE_ACTORS
Spawn actors muted and immediatelly mute existing actors.
Definition: RoRnet.h:130
RoR::OutGauge::Update
bool Update(float dt, ActorPtr truck)
Definition: OutGauge.cpp:103
RoR::App::diag_preset_terrain
CVar * diag_preset_terrain
Definition: Application.cpp:140
RoR::ScriptUnitID_t
int ScriptUnitID_t
Unique sequentially generated ID of a loaded and running scriptin session. Use ScriptEngine::getScrip...
Definition: ForwardDeclarations.h:41
RoR::Console::CONSOLE_MSGTYPE_INFO
@ CONSOLE_MSGTYPE_INFO
Generic message.
Definition: Console.h:60
RoR::GameContext::SpawnPreselectedActor
void SpawnPreselectedActor(std::string const &preset_vehicle, std::string const &preset_veh_config)
needs Character to exist
Definition: GameContext.cpp:624
RoR::ASMANIP_SCRIPT_LOADED
@ ASMANIP_SCRIPT_LOADED
Triggered after the script's main() completed; may trigger additional processing (for example,...
Definition: ScriptEvents.h:75
RoR::App::sim_terrain_gui_name
CVar * sim_terrain_gui_name
Definition: Application.cpp:98
RoR::RepairMode::UpdateInputEvents
void UpdateInputEvents(float dt)
Definition: RepairMode.cpp:30
RoR::App::sys_screenshot_dir
CVar * sys_screenshot_dir
Definition: Application.cpp:171
RoR::App::app_custom_scripts
CVar * app_custom_scripts
Definition: Application.cpp:92
RoR::MSG_GUI_CLOSE_MENU_REQUESTED
@ MSG_GUI_CLOSE_MENU_REQUESTED
Definition: Application.h:138
RoR::MSG_NET_CONNECT_PROGRESS
@ MSG_NET_CONNECT_PROGRESS
Definition: Application.h:99
RoR::App::GetMumble
MumbleIntegration * GetMumble()
Definition: Application.cpp:276
Collisions.h
RoR::GameContext::GetRepairMode
RepairMode & GetRepairMode()
Definition: GameContext.h:169
RoR::AppContext::SetUpInput
bool SetUpInput()
Definition: AppContext.cpp:63
ErrorUtils::ShowError
static int ShowError(Ogre::UTFString title, Ogre::UTFString message)
shows a simple error message box
Definition: ErrorUtils.cpp:43
RoR::MSG_SIM_MUTE_NET_ACTOR_REQUESTED
@ MSG_SIM_MUTE_NET_ACTOR_REQUESTED
Payload = ActorPtr* (owner)
Definition: Application.h:128
GUI_GameControls.h
RoR::MSG_SIM_MODIFY_FREEFORCE_REQUESTED
@ MSG_SIM_MODIFY_FREEFORCE_REQUESTED
Payload = RoR::FreeForceRequest* (owner)
Definition: Application.h:134
RoR::GfxActor::SetAllMeshesVisible
void SetAllMeshesVisible(bool value)
Definition: GfxActor.cpp:3376
RoR::ScriptCallbackArgs::node
NodeNum_t node
Definition: ScriptEngine.h:103
RoR::MSG_SIM_PAUSE_REQUESTED
@ MSG_SIM_PAUSE_REQUESTED
Definition: Application.h:116
RoR::BOAT
@ BOAT
its a boat
Definition: SimData.h:95
RoR::ActorState::NETWORKED_OK
@ NETWORKED_OK
not simulated (remote) actor
RoR::ScriptEventArgs::arg6ex
std::string arg6ex
Definition: ScriptEvents.h:113
MumbleIntegration.h
WinMain
INT WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT)
Definition: main.cpp:1977
RoR::ActorLinkingRequestType::TIE_TOGGLE
@ TIE_TOGGLE
RoR::Actor::ar_state
ActorState ar_state
Definition: Actor.h:453
RoR::GUI::RepositorySelector::ShowError
void ShowError(CurlFailInfo *failinfo)
Definition: GUI_RepositorySelector.cpp:1226
RoR::GUIManager::MouseCursorVisibility::HIDDEN
@ HIDDEN
Hidden as inactive, will re-appear the moment user moves mouse.
RoR::GameContext::UpdateTruckInputEvents
void UpdateTruckInputEvents(float dt)
Definition: GameContext.cpp:1806
SOUND_KILL
#define SOUND_KILL(_ACTOR_, _TRIG_)
Definition: SoundScriptManager.h:38
RoR::MSG_SIM_LOAD_SAVEGAME_REQUESTED
@ MSG_SIM_LOAD_SAVEGAME_REQUESTED
Definition: Application.h:119
RoR::MODCACHEACTIVITY_BUNDLE_LOADED
@ MODCACHEACTIVITY_BUNDLE_LOADED
Args: #1 type, #2 entry number, –, –, #5 rg name.
Definition: ScriptEvents.h:96
RoR::GfxActor::GetSimDataBuffer
ActorSB & GetSimDataBuffer()
Definition: GfxActor.h:127
RoR
Definition: AppContext.h:36
RoR::ActorManager::GetActorById
const ActorPtr & GetActorById(ActorInstanceID_t actor_id)
Definition: ActorManager.cpp:1132
RoR::ContentManager::ResourcePack::FONTS
static const ResourcePack FONTS
Definition: ContentManager.h:56
RoR::Log
void Log(const char *msg)
The ultimate, application-wide logging function. Adds a line (any length) in 'RoR....
Definition: Application.cpp:422
RoR::ActorLinkingRequestType::HOOK_LOCK
@ HOOK_LOCK
RoR::App::app_force_cache_purge
CVar * app_force_cache_purge
Definition: Application.cpp:88
RoR::ScriptCategory::CUSTOM
@ CUSTOM
Loaded by user via either: A) ingame console 'loadscript'; B) RoR.cfg 'app_custom_scripts'; C) comman...
RoR::ActorManager::CleanUpSimulation
void CleanUpSimulation()
Call this after simulation loop finishes.
Definition: ActorManager.cpp:858
RoR::App::GetGfxScene
GfxScene * GetGfxScene()
Definition: Application.cpp:279
RoR::GameContext::GetActorManager
ActorManager * GetActorManager()
Definition: GameContext.h:127
RoR::CVar::setStr
void setStr(std::string const &str)
Definition: CVar.h:83
RoR::SE_ANGELSCRIPT_THREAD_STATUS
@ SE_ANGELSCRIPT_THREAD_STATUS
Sent by background threads (i.e. CURL) when there's something important (like finishing a download)....
Definition: ScriptEvents.h:58
RoR::GUIManager::GameMainMenu
GUI::GameMainMenu GameMainMenu
Definition: GUIManager.h:115
RoR::MSG_APP_SHUTDOWN_REQUESTED
@ MSG_APP_SHUTDOWN_REQUESTED
Definition: Application.h:85
RoR::FileExists
bool FileExists(const char *path)
Path must be UTF-8 encoded.
Definition: PlatformUtils.cpp:163
main
int main(int argc, char *argv[])
Definition: main.cpp:73
RoR::ScriptEventArgs::arg1
int arg1
Definition: ScriptEvents.h:107
RoR::MSG_NET_DISCONNECT_REQUESTED
@ MSG_NET_DISCONNECT_REQUESTED
Definition: Application.h:103
RoR::Console::processCommandLine
void processCommandLine(int argc, char *argv[])
Definition: AppCommandLine.cpp:71
RoR::LanguageEngine::setup
void setup()
Definition: Language.cpp:48
RoR::GUIManager::MouseCursorVisibility::VISIBLE
@ VISIBLE
Visible, will be auto-hidden if not moving for a while.
RoR::GameContext::CreatePlayerCharacter
void CreatePlayerCharacter()
Terrain must be loaded.
Definition: GameContext.cpp:840
RoR::GameContext::UpdateSkyInputEvents
void UpdateSkyInputEvents(float dt)
Definition: GameContext.cpp:1212
RoR::ScriptEventArgs::arg3ex
int arg3ex
Definition: ScriptEvents.h:110
RoR::GameContext::GetTerrain
const TerrainPtr & GetTerrain()
Definition: GameContext.h:117
RoR::MSG_SIM_SCRIPT_EVENT_TRIGGERED
@ MSG_SIM_SCRIPT_EVENT_TRIGGERED
Payload = RoR::ScriptEventArgs* (owner)
Definition: Application.h:130
RoR::OutGauge::Connect
void Connect()
Definition: OutGauge.cpp:58
RoR::Message::type
MsgType type
Definition: GameContext.h:57
RoR::GameContext::HandleSavegameHotkeys
void HandleSavegameHotkeys()
Definition: Savegame.cpp:99
RoR::Network::StopConnecting
void StopConnecting()
Definition: Network.cpp:419
RoR::Actor::muteAllSounds
void muteAllSounds()
Definition: Actor.cpp:3767
Generated by   doxygen 1.8.17