Access to basic engine properties.
    public static class Engine

The Engine class allows you to query and modify the project’s run-time parameters, such as frames per second, time scale, and others.

Inheritance Chain

Static Properties

    public static bool EditorHint { get; set; }

If true, it is running inside the editor. Useful for tool scripts.

    public static int IterationsPerSecond { get; set; }

The number of fixed iterations per second (for fixed process and physics).

    public static float PhysicsJitterFix { get; set; }

    public static Object Singleton { get; }

    public static int TargetFps { get; set; }

The desired frames per second. If the hardware cannot keep up, this setting may not be respected. A value of 0 means no limit.

    public static float TimeScale { get; set; }

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.

Static Methods

    public static Dictionary GetAuthorInfo()

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

    public static Godot.Collections.Array GetCopyrightInfo()

Returns an Array of copyright information Dictionaries.

name - String, component name

parts - Array of Dictionaries {files, copyright, license} describing subsections of the component

    public static Dictionary GetDonorInfo()

Returns a Dictionary of Arrays of donor names.

{platinum_sponsors, gold_sponsors, mini_sponsors, gold_donors, silver_donors, bronze_donors}

    public static int GetFramesDrawn()

Returns the total number of frames drawn.

    public static float GetFramesPerSecond()

Returns the frames per second of the running game.

    [Obsolete("GetIterationsPerSecond is deprecated. Use the IterationsPerSecond property instead.")]
    public static int GetIterationsPerSecond()

Getter for IterationsPerSecond

    public static Dictionary GetLicenseInfo()

Returns Dictionary of licenses used by Godot and included third party components.

    public static string GetLicenseText()

Returns Godot license text.

    public static MainLoop GetMainLoop()

Returns the main loop object (see MainLoop and SceneTree).

    public static float GetPhysicsInterpolationFraction()

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.

    [Obsolete("GetPhysicsJitterFix is deprecated. Use the PhysicsJitterFix property instead.")]
    public static float GetPhysicsJitterFix()

Getter for PhysicsJitterFix

    public static Object GetSingleton(string name)

    [Obsolete("GetTargetFps is deprecated. Use the TargetFps property instead.")]
    public static int GetTargetFps()

Getter for TargetFps

    [Obsolete("GetTimeScale is deprecated. Use the TimeScale property instead.")]
    public static float GetTimeScale()

Getter for TimeScale

    public static Dictionary GetVersionInfo()

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:

[codeblock]

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

[/codeblock]

    public static bool HasSingleton(string name)

    [Obsolete("IsEditorHint is deprecated. Use the EditorHint property instead.")]
    public static bool IsEditorHint()

Getter for EditorHint

    public static bool IsInPhysicsFrame()

Returns true if the game is inside the fixed process and physics phase of the game loop.

    [Obsolete("SetEditorHint is deprecated. Use the EditorHint property instead.")]
    public static void SetEditorHint(bool enabled)

Setter for EditorHint

    [Obsolete("SetIterationsPerSecond is deprecated. Use the IterationsPerSecond property instead.")]
    public static void SetIterationsPerSecond(int iterationsPerSecond)

Setter for IterationsPerSecond

    [Obsolete("SetPhysicsJitterFix is deprecated. Use the PhysicsJitterFix property instead.")]
    public static void SetPhysicsJitterFix(float physicsJitterFix)

Setter for PhysicsJitterFix

    [Obsolete("SetTargetFps is deprecated. Use the TargetFps property instead.")]
    public static void SetTargetFps(int targetFps)

Setter for TargetFps

    [Obsolete("SetTimeScale is deprecated. Use the TimeScale property instead.")]
    public static void SetTimeScale(float timeScale)

Setter for TimeScale

Tags: