SuperTuxKart
Loading...
Searching...
No Matches
Public Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
MainLoop Class Reference

Management class for the whole gameflow, this is where the main-loop is. More...

#include <main_loop.hpp>

Public Member Functions

 MainLoop (unsigned parent_pid, bool download_assets=false)
 
void run ()
 Run the actual main loop.
 
void abort ()
 Set the abort flag, causing the mainloop to be left.
 
void requestAbort ()
 
void setThrottleFPS (bool throttle)
 
void setAllowLargeDt (bool enable)
 
void renderGUI (int phase, int loop_index=-1, int loop_size=-1)
 Renders the GUI.
 
bool isAborted () const
 Returns true if STK is to be stoppe.
 
void setFrameBeforeLoadingWorld ()
 
void setTicksAdjustment (int ticks)
 
void setPaused (bool val)
 
bool isPaused () const
 

Private Types

using TimePoint = std::chrono::steady_clock::time_point
 

Private Member Functions

double getLimitedDt ()
 Returns the current dt, which guarantees a limited frame rate.
 
void updateRace (int ticks, bool fast_forward)
 Updates all race related objects.
 
double convertToTime (const TimePoint &cur, const TimePoint &prev) const
 

Private Attributes

std::atomic_bool m_abort
 True if the main loop should exit.
 
std::atomic_bool m_request_abort
 
std::atomic_bool m_paused
 
bool m_throttle_fps
 True if the frame rate should be throttled.
 
bool m_allow_large_dt
 True if dt is not decreased for low fps.
 
bool m_frame_before_loading_world
 
bool m_download_assets
 
Synchronised< int > m_ticks_adjustment
 
TimePoint m_curr_time
 
TimePoint m_prev_time
 
unsigned m_parent_pid
 

Detailed Description

Management class for the whole gameflow, this is where the main-loop is.

Member Function Documentation

◆ getLimitedDt()

double MainLoop::getLimitedDt ( )
private

Returns the current dt, which guarantees a limited frame rate.

If dt is too low (the frame rate too high), the process will sleep to reach the maximum frame rate.

◆ renderGUI()

void MainLoop::renderGUI ( int  phase,
int  loop_index = -1,
int  loop_size = -1 
)

Renders the GUI.

This function is used during loading a track to get a responsive GUI, and allow GUI animations (like a progress bar) to be shown.

Parameters
phaseAn integer indicated a phase. The maximum number of phases is used to show a progress bar. The values are between 0 and 8200.
loop_indexIf the call is from a loop, the current loop index.
loop_sizeThe number of loop iterations. Used to smooth update e.g. a progress bar.

◆ run()

void MainLoop::run ( )

Run the actual main loop.

The sequence in which various parts of STK are updated is:

  • Determine next time step size (getLimitedDt). This takes maximum fps into account (i.e. sleep if the fps would be too high), and will actually slow down the in-game clock if the fps are too low (if more than 3/60 of a second have passed, more than 3 physics time steps would be needed, and physics do at most 3 time steps).
  • if a race is taking place (i.e. not only a menu being shown), call updateRace(), which is a thin wrapper around a call to World::updateWorld():
    • Update history manager (which will either set the kart position and/or controls when replaying, or store the current info for a replay). This is mostly for debugging only (though available even in release mode).
    • Updates Replays - either storing data when not replaying, or updating kart positions/control when replaying).
    • Calls WorldStatus::update(), which updates the race state (e.g. go from 'ready' to 'set' etc), and clock.
    • Updates the physics (Physics::update()). This will simulate all physical objects for the specified time with bullet.
    • Updates all karts (Kart::update()). Obviously the update function does a lot more than what is described here, this is only supposed to be a very high level overview:
      • Updates its rewinder (to store potentially changed controls as events) in KartRewinder::update().
      • Calls Moveable::update(), which takes the new position from the physics and saves it (and computes dependent values, like heading, local velocity).
      • Updates its controller. This is either:
        • an AI using SkiddingController::update() (which then will compute the new controls), or
        • a player controller using PlayerController::update(), which will handle smooth steering (in case of digital input devices steering is adjusted a bit over time to avoid an instant change from all left to all right). Input events will be handled when updating the irrlicht driver later at the end of the main loop.
      • Updates kart animation (like rescue, ...) if one is shown atm.
      • Update attachments.
      • update physics, i.e. taking the current steering and updating the bullet raycast vehicle with that data. The settings are actually only used in the next frame when the physics are updated.
    • Updates all cameras via Camera::update(). The camera position and rotation is adjusted according to the position etc of the kart (and special circumstances like rescue, falling).
    • Updates all projectiles using the projectile manager. Some of the projectiles are mostly handled by the physics (e.g. a cake will mainly check if it's out of bounds), others (like basket ball) do all their aiming and movement here.
    • Updates the rewind manager to store rewind states.
  • Updates the music manager.
  • Updates the input manager (which only updates internal time, actual input handling follows late)
  • Updates the wiimote manager. This will read the data of all wiimotes and feed the corresponding events to the irrlicht event system.
  • Updates the STK internal gui engine. This updates all widgets, and e.g. takes care of the rotation of the karts in the KartSelection screen using the ModelViewWidget.
  • Updates STK's irrlicht driver IrrDriver::update():
    • Calls Irrlicht's beginScene() .
    • Renders the scene (several times with different viewport if split screen is being used)
    • Calls GUIEngine::render(), which renders all widgets with the help of Irrlicht's GUIEnvironment (drawAll()). This will also handle all events, i.e. all input is now handled (e.g. steering, firing etc are all set in the corresponding karts depending on user input).
    • Calls Irrlicht's endScene()

◆ updateRace()

void MainLoop::updateRace ( int  ticks,
bool  fast_forward 
)
private

Updates all race related objects.

Parameters
ticksNumber of ticks (physics steps) to simulate - should be 1.
fast_forwardIf true, then only rewinders in network will be updated, but not the physics.

The documentation for this class was generated from the following files: