Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

MainLoop

Hérite de : Object

Hérité par : SceneTree

La classe abstraite de base pour la boucle principale du jeu.

Description

MainLoop is the abstract base class for a Godot project's game loop. It is inherited by SceneTree, which is the default game loop implementation used in Godot projects, though it is also possible to write and use one's own MainLoop subclass instead of the scene tree.

Upon the application start, a MainLoop implementation must be provided to the OS; otherwise, the application will exit. This happens automatically (and a SceneTree is created) unless a MainLoop Script is provided from the command line (with e.g. godot -s my_loop.gd) or the ProjectSettings.application/run/main_loop_type project setting is overwritten.

Here is an example script implementing a simple MainLoop:

class_name CustomMainLoop
extends MainLoop

var time_elapsed = 0

func _initialize():
    print("Initialized:")
    print("  Starting time: %s" % str(time_elapsed))

func _process(delta):
    time_elapsed += delta
    # Return true to end the main loop.
    return Input.get_mouse_button_mask() != 0 || Input.is_key_pressed(KEY_ESCAPE)

func _finalize():
    print("Finalized:")
    print("  End time: %s" % str(time_elapsed))

using Godot;

[GlobalClass]
public partial class CustomMainLoop : MainLoop
{
    private double _timeElapsed = 0;

    public override void _Initialize()
    {
        GD.Print("Initialized:");
        GD.Print($"  Starting Time: {_timeElapsed}");
    }

    public override bool _Process(double delta)
    {
        _timeElapsed += delta;
        // Return true to end the main loop.
        return Input.GetMouseButtonMask() != 0 || Input.IsKeyPressed(Key.Escape);
    }

    private void _Finalize()
    {
        GD.Print("Finalized:");
        GD.Print($"  End Time: {_timeElapsed}");
    }
}

Méthodes

void	_finalize() virtual
void	_initialize() virtual
bool	_physics_process(delta: float) virtual
bool	_process(delta: float) virtual

Signaux

on_request_permissions_result(permission: String, granted: bool) 🔗

Émis quand l'utilisateur répond à une demande de permission.

Constantes

NOTIFICATION_OS_MEMORY_WARNING = 2009 🔗

Notification reçue de l'OS lorsque l'application dépasse sa mémoire attribuée.

Spécifique à la plate-forme iOS.

NOTIFICATION_TRANSLATION_CHANGED = 2010 🔗

La notification reçue quand les traductions peuvent avoir changé. Peut être déclenchée quand l'utilisateur modifie les paramètres régionaux. Permet de réagir aux changements de langue, par exemple en modifiant le texte des interfaces utilisateur à la volée. Pratique lorsque vous utilisez la prise en charge intégrée des traductions, comme par le biais de Object.tr().

NOTIFICATION_WM_ABOUT = 2011 🔗

Notification reçue de l'OS lorsqu'une requête d'information "À propos"/"About" est envoyée.

Spécifique à la plateforme macOS.

NOTIFICATION_CRASH = 2012 🔗

Notification reçue depuis le gestionnaire de plantage de Godot quand le moteur est sur le point de planter.

Implémenté sur les environnements de bureau si le gestionnaire de plantage est activé.

NOTIFICATION_OS_IME_UPDATE = 2013 🔗

Notification received from the OS when an update of the Input Method Engine occurs (e.g. change of IME cursor position or composition string).

Implemented on desktop and web platforms.

NOTIFICATION_APPLICATION_RESUMED = 2014 🔗

Notification reçue du système d'exploitation une fois de retour sur l'application.

Spécifique aux plateformes Android et iOS.

NOTIFICATION_APPLICATION_PAUSED = 2015 🔗

Notification reçue du système d'exploitation lorsque l'application est mise en pause.

Spécifique aux plateformes Android et iOS.

Note : Sur iOS, vous n'avez qu'environ 5 secondes pour terminer une tâche commencée par ce signal. Si vous dépassez ce temps attribué, iOS va tuer l'application au lieu de la mettre en pause.

NOTIFICATION_APPLICATION_FOCUS_IN = 2016 🔗

Notification reçue du système d'exploitation lorsque l'application prend le focus, c.à.d. lors du changement de focus du bureau de l'OS ou d'une application tierce vers n'importe quelle fenêtre de l'instance Godot.

Implémentée sur les plateformes mobiles et de bureau.

NOTIFICATION_APPLICATION_FOCUS_OUT = 2017 🔗

Notification reçue du système d'exploitation lorsque l'application perd le focus, c.à.d. lors du changement de focus de n'importe quelle fenêtre de l'instance Godot vers le bureau de l'OS ou une application tierce.

Implémentée sur les plateformes mobiles et de bureau.

NOTIFICATION_TEXT_SERVER_CHANGED = 2018 🔗

Notification received when text server is changed.

NOTIFICATION_APPLICATION_PIP_MODE_ENTERED = 2019 🔗

Notification received when the application enters picture-in-picture mode.

NOTIFICATION_APPLICATION_PIP_MODE_EXITED = 2020 🔗

Notification received when the application exits picture-in-picture mode.

Descriptions des méthodes

void _finalize() virtual 🔗

Appelé avant que le programme se termine.

void _initialize() virtual 🔗

Appelé une fois lors de l’initialisation.

bool _physics_process(delta: float) virtual 🔗

Called each physics tick. delta is the logical time between physics ticks in seconds and is equal to Engine.time_scale / Engine.physics_ticks_per_second. Equivalent to Node._physics_process().

If implemented, the method must return a boolean value. true ends the main loop, while false lets it proceed to the next step.

Note: _physics_process() may be called up to Engine.max_physics_steps_per_frame times per (idle) frame. This step limit may be reached when the engine is suffering performance issues.

Note: Accumulated delta may diverge from real world seconds.

bool _process(delta: float) virtual 🔗

Called on each idle frame, prior to rendering, and after physics ticks have been processed. delta is the time between frames in seconds. Equivalent to Node._process().

If implemented, the method must return a boolean value. true ends the main loop, while false lets it proceed to the next frame.

Note: When the engine is struggling and the frame rate is lowered, delta will increase. When delta is increased, it's capped at a maximum of Engine.time_scale * Engine.max_physics_steps_per_frame / Engine.physics_ticks_per_second. As a result, accumulated delta may not represent real world time.

Note: When --fixed-fps is enabled or the engine is running in Movie Maker mode (see MovieWriter), process delta will always be the same for every frame, regardless of how much time the frame took to render.

Note: Frame delta may be post-processed by OS.delta_smoothing if this is enabled for the project.