:github_url: hide .. Generated automatically by doc/tools/makerst.py in Godot's source tree. .. DO NOT EDIT THIS FILE, but the Engine.xml source instead. .. The source is found in doc/classes or modules//doc_classes. .. _class_Engine: Engine ====== **Inherits:** :ref:`Object` Access to engine properties. Description ----------- The ``Engine`` singleton allows you to query and modify the project's run-time parameters, such as frames per second, time scale, and others. Properties ---------- +---------------------------+---------------------------------------------------------------------------+----------+ | :ref:`bool` | :ref:`editor_hint` | ``true`` | +---------------------------+---------------------------------------------------------------------------+----------+ | :ref:`int` | :ref:`iterations_per_second` | ``60`` | +---------------------------+---------------------------------------------------------------------------+----------+ | :ref:`float` | :ref:`physics_jitter_fix` | ``0.5`` | +---------------------------+---------------------------------------------------------------------------+----------+ | :ref:`int` | :ref:`target_fps` | ``0`` | +---------------------------+---------------------------------------------------------------------------+----------+ | :ref:`float` | :ref:`time_scale` | ``1.0`` | +---------------------------+---------------------------------------------------------------------------+----------+ Methods ------- +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------+ | :ref:`Dictionary` | :ref:`get_author_info` **(** **)** |const| | +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`get_copyright_info` **(** **)** |const| | +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------+ | :ref:`Dictionary` | :ref:`get_donor_info` **(** **)** |const| | +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`get_frames_drawn` **(** **)** | +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------+ | :ref:`float` | :ref:`get_frames_per_second` **(** **)** |const| | +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`get_idle_frames` **(** **)** |const| | +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------+ | :ref:`Dictionary` | :ref:`get_license_info` **(** **)** |const| | +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`get_license_text` **(** **)** |const| | +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------+ | :ref:`MainLoop` | :ref:`get_main_loop` **(** **)** |const| | +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`get_physics_frames` **(** **)** |const| | +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------+ | :ref:`float` | :ref:`get_physics_interpolation_fraction` **(** **)** |const| | +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------+ | :ref:`Object` | :ref:`get_singleton` **(** :ref:`String` name **)** |const| | +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------+ | :ref:`Dictionary` | :ref:`get_version_info` **(** **)** |const| | +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`has_singleton` **(** :ref:`String` name **)** |const| | +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_in_physics_frame` **(** **)** |const| | +-------------------------------------+-----------------------------------------------------------------------------------------------------------------------+ Property Descriptions --------------------- .. _class_Engine_property_editor_hint: - :ref:`bool` **editor_hint** +-----------+------------------------+ | *Default* | ``true`` | +-----------+------------------------+ | *Setter* | set_editor_hint(value) | +-----------+------------------------+ | *Getter* | is_editor_hint() | +-----------+------------------------+ If ``true``, it is running inside the editor. Useful for tool scripts. ---- .. _class_Engine_property_iterations_per_second: - :ref:`int` **iterations_per_second** +-----------+----------------------------------+ | *Default* | ``60`` | +-----------+----------------------------------+ | *Setter* | set_iterations_per_second(value) | +-----------+----------------------------------+ | *Getter* | get_iterations_per_second() | +-----------+----------------------------------+ The number of fixed iterations per second. This controls how often physics simulation and :ref:`Node._physics_process` methods are run. This value should generally always be set to ``60`` or above, as Godot doesn't interpolate the physics step. As a result, values lower than ``60`` will look stuttery. This value can be increased to make input more reactive or work around tunneling issues, but keep in mind doing so will increase CPU usage. ---- .. _class_Engine_property_physics_jitter_fix: - :ref:`float` **physics_jitter_fix** +-----------+-------------------------------+ | *Default* | ``0.5`` | +-----------+-------------------------------+ | *Setter* | set_physics_jitter_fix(value) | +-----------+-------------------------------+ | *Getter* | get_physics_jitter_fix() | +-----------+-------------------------------+ Controls how much physics ticks are synchronized with real time. For 0 or less, the ticks are synchronized. Such values are recommended for network games, where clock synchronization matters. Higher values cause higher deviation of in-game clock and real clock, but allows to smooth out framerate jitters. The default value of 0.5 should be fine for most; values above 2 could cause the game to react to dropped frames with a noticeable delay and are not recommended. ---- .. _class_Engine_property_target_fps: - :ref:`int` **target_fps** +-----------+-----------------------+ | *Default* | ``0`` | +-----------+-----------------------+ | *Setter* | set_target_fps(value) | +-----------+-----------------------+ | *Getter* | get_target_fps() | +-----------+-----------------------+ The desired frames per second. If the hardware cannot keep up, this setting may not be respected. A value of 0 means no limit. ---- .. _class_Engine_property_time_scale: - :ref:`float` **time_scale** +-----------+-----------------------+ | *Default* | ``1.0`` | +-----------+-----------------------+ | *Setter* | set_time_scale(value) | +-----------+-----------------------+ | *Getter* | get_time_scale() | +-----------+-----------------------+ Controls how fast or slow the in-game clock ticks versus the real life one. It defaults to 1.0. A value of 2.0 means the game moves twice as fast as real life, whilst a value of 0.5 means the game moves at half the regular speed. Method Descriptions ------------------- .. _class_Engine_method_get_author_info: - :ref:`Dictionary` **get_author_info** **(** **)** |const| Returns engine author information in a Dictionary. ``lead_developers`` - Array of Strings, lead developer names ``founders`` - Array of Strings, founder names ``project_managers`` - Array of Strings, project manager names ``developers`` - Array of Strings, developer names ---- .. _class_Engine_method_get_copyright_info: - :ref:`Array` **get_copyright_info** **(** **)** |const| Returns an Array of copyright information Dictionaries. ``name`` - String, component name ``parts`` - Array of Dictionaries {``files``, ``copyright``, ``license``} describing subsections of the component ---- .. _class_Engine_method_get_donor_info: - :ref:`Dictionary` **get_donor_info** **(** **)** |const| Returns a Dictionary of Arrays of donor names. {``platinum_sponsors``, ``gold_sponsors``, ``silver_sponsors``, ``bronze_sponsors``, ``mini_sponsors``, ``gold_donors``, ``silver_donors``, ``bronze_donors``} ---- .. _class_Engine_method_get_frames_drawn: - :ref:`int` **get_frames_drawn** **(** **)** Returns the total number of frames drawn. If the render loop is disabled with ``--disable-render-loop`` via command line, this returns ``0``. See also :ref:`get_idle_frames`. ---- .. _class_Engine_method_get_frames_per_second: - :ref:`float` **get_frames_per_second** **(** **)** |const| Returns the frames per second of the running game. ---- .. _class_Engine_method_get_idle_frames: - :ref:`int` **get_idle_frames** **(** **)** |const| Returns the total number of frames passed since engine initialization which is advanced on each **idle frame**, regardless of whether the render loop is enabled. See also :ref:`get_frames_drawn`. ---- .. _class_Engine_method_get_license_info: - :ref:`Dictionary` **get_license_info** **(** **)** |const| Returns Dictionary of licenses used by Godot and included third party components. ---- .. _class_Engine_method_get_license_text: - :ref:`String` **get_license_text** **(** **)** |const| Returns Godot license text. ---- .. _class_Engine_method_get_main_loop: - :ref:`MainLoop` **get_main_loop** **(** **)** |const| Returns the main loop object (see :ref:`MainLoop` and :ref:`SceneTree`). ---- .. _class_Engine_method_get_physics_frames: - :ref:`int` **get_physics_frames** **(** **)** |const| Returns the total number of frames passed since engine initialization which is advanced on each **physics frame**. ---- .. _class_Engine_method_get_physics_interpolation_fraction: - :ref:`float` **get_physics_interpolation_fraction** **(** **)** |const| Returns the fraction through the current physics tick we are at the time of rendering the frame. This can be used to implement fixed timestep interpolation. ---- .. _class_Engine_method_get_singleton: - :ref:`Object` **get_singleton** **(** :ref:`String` name **)** |const| Returns a global singleton with given ``name``. Often used for plugins, e.g. ``GodotPayment`` on Android. ---- .. _class_Engine_method_get_version_info: - :ref:`Dictionary` **get_version_info** **(** **)** |const| Returns the current engine version information in a Dictionary. ``major`` - Holds the major version number as an int ``minor`` - Holds the minor version number as an int ``patch`` - Holds the patch version number as an int ``hex`` - Holds the full version number encoded as a hexadecimal int with one byte (2 places) per number (see example below) ``status`` - Holds the status (e.g. "beta", "rc1", "rc2", ... "stable") as a String ``build`` - Holds the build name (e.g. "custom_build") as a String ``hash`` - Holds the full Git commit hash as a String ``year`` - Holds the year the version was released in as an int ``string`` - ``major`` + ``minor`` + ``patch`` + ``status`` + ``build`` in a single String The ``hex`` value is encoded as follows, from left to right: one byte for the major, one byte for the minor, one byte for the patch version. For example, "3.1.12" would be ``0x03010C``. **Note:** It's still an int internally, and printing it will give you its decimal representation, which is not particularly meaningful. Use hexadecimal literals for easy version comparisons from code: :: if Engine.get_version_info().hex >= 0x030200: # Do things specific to version 3.2 or later else: # Do things specific to versions before 3.2 ---- .. _class_Engine_method_has_singleton: - :ref:`bool` **has_singleton** **(** :ref:`String` name **)** |const| Returns ``true`` if a singleton with given ``name`` exists in global scope. ---- .. _class_Engine_method_is_in_physics_frame: - :ref:`bool` **is_in_physics_frame** **(** **)** |const| Returns ``true`` if the game is inside the fixed process and physics phase of the game loop. .. |virtual| replace:: :abbr:`virtual (This method should typically be overridden by the user to have any effect.)` .. |const| replace:: :abbr:`const (This method has no side effects. It doesn't modify any of the instance's member variables.)` .. |vararg| replace:: :abbr:`vararg (This method accepts any number of arguments after the ones described here.)`