RigsofRods
Soft-body Physics Simulation
GfxScene.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 "GfxScene.h"
23 
24 #include "AppContext.h"
25 #include "Actor.h"
26 #include "ActorManager.h"
27 #include "Console.h"
28 #include "DustPool.h"
29 #include "HydraxWater.h"
30 #include "GameContext.h"
31 #include "GUIManager.h"
32 #include "GUIUtils.h"
33 #include "GUI_DirectionArrow.h"
34 #include "OverlayWrapper.h"
35 #include "SkyManager.h"
36 #include "SkyXManager.h"
37 #include "TerrainGeometryManager.h"
38 #include "Terrain.h"
39 #include "TerrainObjectManager.h"
40 #include "Utils.h"
41 
42 #include "imgui_internal.h"
43 
44 #include <Ogre.h>
45 
46 using namespace Ogre;
47 using namespace RoR;
48 
49 void GfxScene::CreateDustPools()
50 {
51  ROR_ASSERT(m_dustpools.size() == 0);
52  m_dustpools["dust"] = new DustPool(m_scene_manager, "tracks/Dust", 20);
53  m_dustpools["clump"] = new DustPool(m_scene_manager, "tracks/Clump", 20);
54  m_dustpools["sparks"] = new DustPool(m_scene_manager, "tracks/Sparks", 10);
55  m_dustpools["drip"] = new DustPool(m_scene_manager, "tracks/Drip", 50);
56  m_dustpools["splash"] = new DustPool(m_scene_manager, "tracks/Splash", 20);
57  m_dustpools["ripple"] = new DustPool(m_scene_manager, "tracks/Ripple", 20);
58 }
59 
60 void GfxScene::ClearScene()
61 {
62  // Delete dustpools
63  for (auto itor : m_dustpools)
64  {
65  itor.second->Discard(m_scene_manager);
66  delete itor.second;
67  }
68  m_dustpools.clear();
69 
70  // Delete game elements
71  m_all_gfx_actors.clear();
72  m_all_gfx_characters.clear();
73 
74  // Wipe scene manager
75  m_scene_manager->clearScene();
76 
77  // Recover from the wipe
80 }
81 
82 void GfxScene::Init()
83 {
84  ROR_ASSERT(!m_scene_manager);
85  m_scene_manager = App::GetAppContext()->GetOgreRoot()->createSceneManager(Ogre::ST_EXTERIOR_CLOSE, "main_scene_manager");
86 
87  m_skidmark_conf.LoadDefaultSkidmarkDefs();
88 }
89 
90 void GfxScene::UpdateScene(float dt)
91 {
92  // NOTE: The `dt` parameter here is simulation time (0 when paused), not real time!
93  // ================================================================================
94 
95  // Actors - start threaded tasks
96  for (GfxActor* gfx_actor: m_live_gfx_actors)
97  {
98  gfx_actor->UpdateFlexbodies(); // Push flexbody tasks to threadpool
99  gfx_actor->UpdateWheelVisuals(); // Push flexwheel tasks to threadpool
100  }
101 
102  // Var
103  GfxActor* player_gfx_actor = nullptr;
104  if (m_simbuf.simbuf_player_actor != nullptr)
105  {
106  player_gfx_actor = m_simbuf.simbuf_player_actor->GetGfxActor();
107  }
108 
109  // FOV
110  if (m_simbuf.simbuf_camera_behavior != CameraManager::CAMERA_BEHAVIOR_STATIC)
111  {
112  float fov = (m_simbuf.simbuf_camera_behavior == CameraManager::CAMERA_BEHAVIOR_VEHICLE_CINECAM)
114  RoR::App::GetCameraManager()->GetCamera()->setFOVy(Ogre::Degree(fov));
115  }
116 
117  // Particles
118  if (App::gfx_particles_mode->getInt() == 1)
119  {
120  // Generate particles as needed
121  for (GfxActor* gfx_actor: m_all_gfx_actors)
122  {
123  float dt_actor = (!gfx_actor->GetSimDataBuffer().simbuf_physics_paused) ? dt : 0.f;
124  gfx_actor->UpdateParticles(dt_actor);
125  }
126 
127  // Update particle movement
128  for (auto itor : m_dustpools)
129  {
130  itor.second->update();
131  }
132  }
133 
134  // Realtime reflections on player vehicle
135  // IMPORTANT: Toggles visibility of all meshes -> must be done before any other visibility control is evaluated (i.e. aero propellers)
136  if (player_gfx_actor != nullptr)
137  {
138  // Safe to be called here, only modifies OGRE objects, doesn't read any physics state.
139  m_envmap.UpdateEnvMap(player_gfx_actor->GetSimDataBuffer().simbuf_pos, player_gfx_actor);
140  }
141 
142  // Terrain - animated meshes and paged geometry
144 
145  // Terrain - lightmap; TODO: ported as-is from Terrain::update(), is it needed? ~ only_a_ptr, 05/2018
146  App::GetGameContext()->GetTerrain()->getGeometryManager()->UpdateMainLightPosition(); // TODO: Is this necessary? I'm leaving it here just in case ~ only_a_ptr, 04/2017
147 
148  // Terrain - water
150  if (water)
151  {
152  if (player_gfx_actor != nullptr)
153  {
154  water->SetReflectionPlaneHeight(water->CalcWavesHeight(player_gfx_actor->GetSimDataBuffer().simbuf_pos));
155  }
156  else
157  {
159  }
160  water->FrameStepWater(dt);
161  }
162 
163  // Terrain - sky
164 #ifdef USE_CAELUM
165  SkyManager* sky = App::GetGameContext()->GetTerrain()->getSkyManager();
166  if (sky != nullptr)
167  {
168  sky->DetectSkyUpdate();
169  }
170 #endif
171 
173  if (skyx_man != nullptr)
174  {
175  skyx_man->update(dt); // Light update
176  }
177 
178  // GUI - race
179  if (m_simbuf.simbuf_race_in_progress != m_simbuf.simbuf_race_in_progress_prev)
180  {
181  if (m_simbuf.simbuf_race_in_progress) // Started
182  {
184  }
185  else // Ended
186  {
188  }
189  }
190  if (m_simbuf.simbuf_race_in_progress)
191  {
193  }
194 
195  // GUI - vehicle pressure
196  if (m_simbuf.simbuf_player_actor)
197  {
198  App::GetOverlayWrapper()->UpdatePressureOverlay(m_simbuf.simbuf_player_actor->GetGfxActor());
199  }
200 
201  // HUD - network labels (always update)
202  for (GfxActor* gfx_actor: m_all_gfx_actors)
203  {
204  gfx_actor->UpdateNetLabels(dt);
205  }
206 
207  // Player avatars
208  for (GfxCharacter* a: m_all_gfx_characters)
209  {
210  a->UpdateCharacterInScene();
211  }
212 
213  // Actors - update misc visuals
214  for (GfxActor* gfx_actor: m_all_gfx_actors)
215  {
216  float dt_actor = (!gfx_actor->GetSimDataBuffer().simbuf_physics_paused) ? dt : 0.f;
217  if (gfx_actor->IsActorLive())
218  {
219  gfx_actor->UpdateRods();
220  gfx_actor->UpdateCabMesh();
221  gfx_actor->UpdateWingMeshes();
222  gfx_actor->UpdateAirbrakes();
223  gfx_actor->UpdateCParticles();
224  gfx_actor->UpdateExhausts();
225  gfx_actor->UpdateAeroEngines();
226  gfx_actor->UpdatePropAnimations(dt_actor);
227  gfx_actor->UpdateRenderdashRTT();
228  }
229  // Beacon flares must always be updated
230  gfx_actor->UpdateProps(dt_actor, (gfx_actor == player_gfx_actor));
231  // Blinkers (turn signals) must always be updated
232  gfx_actor->UpdateFlares(dt_actor, (gfx_actor == player_gfx_actor));
233  }
234  if (player_gfx_actor != nullptr)
235  {
236  float dt_actor = (!player_gfx_actor->GetSimDataBuffer().simbuf_physics_paused) ? dt : 0.f;
237  player_gfx_actor->UpdateVideoCameras(dt_actor);
238 
239  // The old-style render-to-texture dashboard (based on OGRE overlays)
240  if (m_simbuf.simbuf_player_actor->ar_driveable == TRUCK && m_simbuf.simbuf_player_actor->ar_engine != nullptr)
241  {
243  }
244  else if (m_simbuf.simbuf_player_actor->ar_driveable == AIRPLANE)
245  {
246  RoR::App::GetOverlayWrapper()->UpdateAerialHUD(player_gfx_actor);
247  }
248  }
249 
250  App::GetGuiManager()->DrawSimGuiBuffered(player_gfx_actor);
251 
253 
254  // Actors - finalize threaded tasks
255  for (GfxActor* gfx_actor: m_live_gfx_actors)
256  {
257  gfx_actor->FinishWheelUpdates();
258  gfx_actor->FinishFlexbodyTasks();
259  }
260 }
261 
262 void GfxScene::SetParticlesVisible(bool visible)
263 {
264  for (auto itor : m_dustpools)
265  {
266  itor.second->setVisible(visible);
267  }
268 }
269 
270 DustPool* GfxScene::GetDustPool(const char* name)
271 {
272  auto found = m_dustpools.find(name);
273  if (found != m_dustpools.end())
274  {
275  return found->second;
276  }
277  else
278  {
279  return nullptr;
280  }
281 }
282 
283 void GfxScene::RegisterGfxActor(RoR::GfxActor* gfx_actor)
284 {
285  m_all_gfx_actors.push_back(gfx_actor);
286 }
287 
288 void GfxScene::BufferSimulationData()
289 {
290  m_simbuf.simbuf_player_actor = App::GetGameContext()->GetPlayerActor();
291  m_simbuf.simbuf_character_pos = App::GetGameContext()->GetPlayerCharacter()->getPosition();
292  m_simbuf.simbuf_sim_paused = App::GetGameContext()->GetActorManager()->IsSimulationPaused();
293  m_simbuf.simbuf_sim_speed = App::GetGameContext()->GetActorManager()->GetSimulationSpeed();
294  m_simbuf.simbuf_camera_behavior = App::GetCameraManager()->GetCurrentBehavior();
295 
296  // Race system
297  m_simbuf.simbuf_race_time = App::GetGameContext()->GetRaceSystem().GetRaceTime();
298  m_simbuf.simbuf_race_best_time = App::GetGameContext()->GetRaceSystem().GetRaceBestTime();
299  m_simbuf.simbuf_race_time_diff = App::GetGameContext()->GetRaceSystem().GetRaceTimeDiff();
300  m_simbuf.simbuf_race_in_progress_prev = m_simbuf.simbuf_race_in_progress;
301  m_simbuf.simbuf_race_in_progress = App::GetGameContext()->GetRaceSystem().IsRaceInProgress();
302  m_simbuf.simbuf_dir_arrow_target = App::GetGameContext()->GetRaceSystem().GetDirArrowTarget();
303  m_simbuf.simbuf_dir_arrow_text = App::GetGameContext()->GetRaceSystem().GetDirArrowText();
304  m_simbuf.simbuf_dir_arrow_visible = App::GetGameContext()->GetRaceSystem().IsDirArrowVisible();
305 
306  m_live_gfx_actors.clear();
307  for (GfxActor* a: m_all_gfx_actors)
308  {
309  if (a->IsActorLive() || !a->IsActorInitialized())
310  {
311  a->UpdateSimDataBuffer();
312  m_live_gfx_actors.push_back(a);
313  a->InitializeActor();
314  }
315  }
316 
317  for (GfxCharacter* a: m_all_gfx_characters)
318  {
319  a->BufferSimulationData();
320  }
321 }
322 
323 void GfxScene::RemoveGfxActor(RoR::GfxActor* remove_me)
324 {
325  auto itor = std::remove(m_all_gfx_actors.begin(), m_all_gfx_actors.end(), remove_me);
326  if (itor != m_all_gfx_actors.end())
327  {
328  m_all_gfx_actors.erase(itor, m_all_gfx_actors.end());
329  }
330 }
331 
332 void GfxScene::ForceUpdateSingleGfxActor(RoR::GfxActor* gfx_actor)
333 {
334  // Do the work `UpdateScene()` would, but for a single actor.
335  // Needed for i.e. terrain editor mode.
336  // ------------------------------------------------------
337 
338  // Start threaded stuff
339  gfx_actor->UpdateFlexbodies(); // Push flexbody tasks to threadpool
340  gfx_actor->UpdateWheelVisuals(); // Push flexwheel tasks to threadpool
341 
342  // Do sync stuff
343  gfx_actor->UpdateRods();
344  gfx_actor->UpdateCabMesh();
345  gfx_actor->UpdateWingMeshes();
346  gfx_actor->UpdateAirbrakes();
347 
348  // Finish threaded stuff
349  gfx_actor->FinishWheelUpdates();
350  gfx_actor->FinishFlexbodyTasks();
351 }
352 
353 void GfxScene::RegisterGfxCharacter(RoR::GfxCharacter* gfx_character)
354 {
355  m_all_gfx_characters.push_back(gfx_character);
356 }
357 
358 void GfxScene::RemoveGfxCharacter(RoR::GfxCharacter* remove_me)
359 {
360  auto itor = std::remove(m_all_gfx_characters.begin(), m_all_gfx_characters.end(), remove_me);
361  if (itor != m_all_gfx_characters.end())
362  {
363  m_all_gfx_characters.erase(itor, m_all_gfx_characters.end());
364  }
365 }
366 
367 void GfxScene::DrawNetLabel(Ogre::Vector3 scene_pos, float cam_dist, std::string const& nick, int colornum)
368 {
369 #if USE_SOCKETW
370 
371  // this ensures that the nickname is always in a readable size
372  float font_size = std::max(0.6, cam_dist / 40.0);
373  std::string caption;
374  if (cam_dist > 1000) // 1000 ... vlen
375  {
376  caption =
377  nick + " (" + TOSTRING((float)(ceil(cam_dist / 100) / 10.0) ) + " km)";
378  }
379  else if (cam_dist > 20) // 20 ... vlen ... 1000
380  {
381  caption =
382  nick + " (" + TOSTRING((int)cam_dist) + " m)";
383  }
384  else // 0 ... vlen ... 20
385  {
386  caption = nick;
387  }
388 
389  // draw with DearIMGUI
390 
391  ImVec2 screen_size = ImGui::GetIO().DisplaySize;
392  World2ScreenConverter world2screen(
393  App::GetCameraManager()->GetCamera()->getViewMatrix(true), App::GetCameraManager()->GetCamera()->getProjectionMatrix(), Ogre::Vector2(screen_size.x, screen_size.y));
394 
395  Ogre::Vector3 pos_xyz = world2screen.Convert(scene_pos);
396 
397  // only draw when in front of camera
398  if (pos_xyz.z < 0.f)
399  {
400  // Align position to whole pixels, to minimize jitter.
401  ImVec2 pos((int)pos_xyz.x+0.5, (int)pos_xyz.y+0.5);
402 
403  ImVec2 text_size = ImGui::CalcTextSize(caption.c_str());
405 
406  ImDrawList* drawlist = GetImDummyFullscreenWindow();
407  ImGuiContext* g = ImGui::GetCurrentContext();
408 
409  ImVec2 text_pos(pos.x - ((text_size.x / 2)), pos.y - ((text_size.y / 2)));
410 
411  // Draw background rectangle
412  const float PADDING = 4.f;
413  drawlist->AddRectFilled(
414  text_pos - ImVec2(PADDING, PADDING),
415  text_pos + text_size + ImVec2(PADDING, PADDING),
416  ImColor(theme.semitransparent_window_bg),
417  ImGui::GetStyle().WindowRounding);
418 
419  // draw colored text
420  Ogre::ColourValue color = App::GetNetwork()->GetPlayerColor(colornum);
421  ImVec4 text_color(color.r, color.g, color.b, 1.f);
422  drawlist->AddText(g->Font, g->FontSize, text_pos, ImColor(text_color), caption.c_str());
423  }
424 
425 #endif // USE_SOCKETW
426 }
427 
428 void GfxScene::AdjustParticleSystemTimeFactor(Ogre::ParticleSystem* psys)
429 {
430  float speed_factor = 0.f;
431  if (App::sim_state->getEnum<SimState>() == SimState::RUNNING && !App::GetGameContext()->GetActorManager()->IsSimulationPaused())
432  {
433  speed_factor = m_simbuf.simbuf_sim_speed;
434  }
435 
436  psys->setSpeedFactor(speed_factor);
437 }
ROR_ASSERT
#define ROR_ASSERT(_EXPR)
Definition: Application.h:40
GameContext.h
Game state manager and message-queue provider.
RoR::IWater::GetStaticWaterHeight
virtual float GetStaticWaterHeight()=0
Returns static water level configured in 'terrn2'.
RoR::App::GetNetwork
Network * GetNetwork()
Definition: Application.cpp:287
RoR::ActorManager::GetSimulationSpeed
float GetSimulationSpeed() const
Definition: ActorManager.h:92
RoR::IWater::CalcWavesHeight
virtual float CalcWavesHeight(Ogre::Vector3 pos)=0
RoR::GfxActor::UpdateAirbrakes
void UpdateAirbrakes()
Definition: GfxActor.cpp:2011
SkyXManager.h
RoR::App::gfx_fov_internal
CVar * gfx_fov_internal
Definition: Application.cpp:240
OverlayWrapper.h
RoR::GUI::DirectionArrow::CreateArrow
void CreateArrow()
Must be called again after OGRE scenemanager is cleared.
Definition: GUI_DirectionArrow.cpp:50
RoR::TRUCK
@ TRUCK
its a truck (or other land vehicle)
Definition: SimData.h:93
RoR::DustPool
Definition: DustPool.h:33
RoR::GUIManager::GuiTheme
Definition: GUIManager.h:79
RoR::App::GetCameraManager
CameraManager * GetCameraManager()
Definition: Application.cpp:278
RoR::App::GetGuiManager
GUIManager * GetGuiManager()
Definition: Application.cpp:272
RoR::IWater::FrameStepWater
virtual void FrameStepWater(float dt)=0
SkyManager.h
RoR::App::GetAppContext
AppContext * GetAppContext()
Definition: Application.cpp:269
RoR::GfxActor::UpdateRods
void UpdateRods()
Definition: GfxActor.cpp:1646
GUIUtils.h
RoR::Terrain::getObjectManager
TerrainObjectManager * getObjectManager()
Definition: Terrain.h:76
RoR::Terrain::getSkyManager
SkyManager * getSkyManager()
Definition: Terrain.cpp:514
RoR::RaceSystem::GetDirArrowText
std::string const & GetDirArrowText() const
Definition: RaceSystem.h:49
TerrainGeometryManager.h
RoR::GameContext::GetPlayerCharacter
Character * GetPlayerCharacter()
Definition: GameContext.cpp:893
RoR::App::gfx_particles_mode
CVar * gfx_particles_mode
Definition: Application.cpp:227
RoR::IWater
< TODO: Mixed gfx+physics (waves) - must be separated ~ only_a_ptr, 02/2018
Definition: IWater.h:32
RoR::App::GetOverlayWrapper
OverlayWrapper * GetOverlayWrapper()
Definition: Application.cpp:271
RoR::OverlayWrapper::UpdateAerialHUD
void UpdateAerialHUD(RoR::GfxActor *ga)
Definition: OverlayWrapper.cpp:741
RoR::OverlayWrapper::UpdateRacingGui
void UpdateRacingGui(RoR::GfxScene *gs)
Definition: OverlayWrapper.cpp:965
AppContext.h
System integration layer; inspired by OgreBites::ApplicationContext.
Console.h
GUI_DirectionArrow.h
Race direction arrow and text info (using OGRE Overlay)
RoR::GfxActor::UpdateCabMesh
void UpdateCabMesh()
Definition: GfxActor.cpp:1951
RoR::GfxActor::FinishFlexbodyTasks
void FinishFlexbodyTasks()
Definition: GfxActor.cpp:3230
RoR::RaceSystem::IsDirArrowVisible
bool IsDirArrowVisible() const
Definition: RaceSystem.h:50
RoR::App::sim_state
CVar * sim_state
Definition: Application.cpp:96
Utils.h
RoR::RaceSystem::GetRaceTime
float GetRaceTime() const
Definition: RaceSystem.cpp:59
RoR::GUIManager::GuiTheme::semitransparent_window_bg
ImVec4 semitransparent_window_bg
Definition: GUIManager.h:92
TerrainObjectManager.h
RoR::World2ScreenConverter::Convert
Ogre::Vector3 Convert(Ogre::Vector3 world_pos)
Definition: Utils.h:89
RoR::GUIManager::DirectionArrow
GUI::DirectionArrow DirectionArrow
Definition: GUIManager.h:134
GUIManager.h
ActorManager.h
Actor.h
RoR::GameContext::GetRaceSystem
RaceSystem & GetRaceSystem()
Definition: GameContext.h:168
RoR::RaceSystem::GetRaceTimeDiff
float GetRaceTimeDiff() const
Definition: RaceSystem.h:42
RoR::OverlayWrapper::UpdatePressureOverlay
void UpdatePressureOverlay(RoR::GfxActor *ga)
Definition: OverlayWrapper.cpp:646
RoR::GfxActor::FinishWheelUpdates
void FinishWheelUpdates()
Definition: GfxActor.cpp:1977
RoR::GetImDummyFullscreenWindow
ImDrawList * GetImDummyFullscreenWindow(const std::string &name="RoR_TransparentFullscreenWindow")
Definition: GUIUtils.cpp:358
RoR::OverlayWrapper::UpdateLandVehicleHUD
void UpdateLandVehicleHUD(RoR::GfxActor *ga)
Definition: OverlayWrapper.cpp:661
RoR::CameraManager::GetCurrentBehavior
CameraBehaviors GetCurrentBehavior() const
Definition: CameraManager.h:62
RoR::GUIManager::GetTheme
GuiTheme & GetTheme()
Definition: GUIManager.h:166
TOSTRING
#define TOSTRING(x)
Definition: Application.h:56
RoR::CameraManager::GetCamera
Ogre::Camera * GetCamera()
Definition: CameraManager.h:64
RoR::GameContext::GetSceneMouse
SceneMouse & GetSceneMouse()
Definition: GameContext.h:170
RoR::CameraManager::ReCreateCameraNode
void ReCreateCameraNode()
Needed since we call Ogre::SceneManager::ClearScene() after end of sim. session.
Definition: CameraManager.cpp:142
RoR::World2ScreenConverter
< Keeps data close for faster access.
Definition: Utils.h:81
RoR::GfxCharacter
Definition: Character.h:99
RoR::Terrain::getGeometryManager
TerrainGeometryManager * getGeometryManager()
Definition: Terrain.h:74
RoR::GUIManager::DrawSimGuiBuffered
void DrawSimGuiBuffered(GfxActor *player_gfx_actor)
Reads data from simbuffer.
Definition: GUIManager.cpp:187
RoR::TerrainGeometryManager::UpdateMainLightPosition
void UpdateMainLightPosition()
Definition: TerrainGeometryManager.cpp:407
RoR::IWater::SetReflectionPlaneHeight
virtual void SetReflectionPlaneHeight(float centerheight)
Definition: IWater.h:53
RoR::SceneMouse::UpdateVisuals
void UpdateVisuals()
Definition: SceneMouse.cpp:212
GfxScene.h
RoR::App::GetGameContext
GameContext * GetGameContext()
Definition: Application.cpp:283
RoR::GfxActor::UpdateVideoCameras
void UpdateVideoCameras(float dt)
Definition: GfxActor.cpp:470
RoR::Character::getPosition
Ogre::Vector3 getPosition()
Definition: Character.cpp:92
RoR::AIRPLANE
@ AIRPLANE
its an airplane
Definition: SimData.h:94
RoR::RaceSystem::GetDirArrowTarget
Ogre::Vector3 GetDirArrowTarget()
Definition: RaceSystem.h:48
RoR::ActorSB::simbuf_pos
Ogre::Vector3 simbuf_pos
Definition: SimBuffers.h:123
RoR::RaceSystem::GetRaceBestTime
float GetRaceBestTime() const
Definition: RaceSystem.h:45
DustPool.h
RoR::ActorSB::simbuf_physics_paused
bool simbuf_physics_paused
Definition: SimBuffers.h:116
RoR::Network::GetPlayerColor
Ogre::ColourValue GetPlayerColor(int color_num)
Definition: Network.cpp:94
RoR::SkyXManager::update
bool update(float dt)
Definition: SkyXManager.cpp:77
RoR::TerrainObjectManager::UpdateTerrainObjects
bool UpdateTerrainObjects(float dt)
Definition: TerrainObjectManager.cpp:1096
RoR::Terrain::getSkyXManager
SkyXManager * getSkyXManager()
Definition: Terrain.h:79
RoR::GfxActor::UpdateWingMeshes
void UpdateWingMeshes()
Definition: GfxActor.cpp:3403
RoR::App::gfx_fov_external
CVar * gfx_fov_external
Definition: Application.cpp:238
RoR::AppContext::GetOgreRoot
Ogre::Root * GetOgreRoot()
Definition: AppContext.h:65
Terrain.h
RoR::GfxActor
Definition: GfxActor.h:52
RoR::CVar::getFloat
float getFloat() const
Definition: CVar.h:96
Ogre
Definition: ExtinguishableFireAffector.cpp:35
RoR::OverlayWrapper::HideRacingOverlay
void HideRacingOverlay()
Definition: OverlayWrapper.cpp:959
RoR::RaceSystem::IsRaceInProgress
bool IsRaceInProgress() const
Definition: RaceSystem.h:36
RoR::ActorManager::IsSimulationPaused
bool IsSimulationPaused() const
Definition: ActorManager.h:93
RoR::GfxActor::UpdateFlexbodies
void UpdateFlexbodies()
Definition: GfxActor.cpp:3191
RoR::GfxActor::UpdateWheelVisuals
void UpdateWheelVisuals()
Definition: GfxActor.cpp:1959
RoR::GameContext::GetPlayerActor
const ActorPtr & GetPlayerActor()
Definition: GameContext.h:134
RoR::OverlayWrapper::ShowRacingOverlay
void ShowRacingOverlay()
Definition: OverlayWrapper.cpp:953
RoR::GfxActor::GetSimDataBuffer
ActorSB & GetSimDataBuffer()
Definition: GfxActor.h:127
RoR
Definition: AppContext.h:36
RoR::GameContext::GetActorManager
ActorManager * GetActorManager()
Definition: GameContext.h:127
RoR::Terrain::getWater
IWater * getWater()
Definition: Terrain.h:83
HydraxWater.h
RoR::SkyXManager
Definition: SkyXManager.h:32
RoR::GameContext::GetTerrain
const TerrainPtr & GetTerrain()
Definition: GameContext.h:117