la classe Time

L'interface pour obtenir des informations sur le temps dans Unity. La fonction Update vous permet de surveiller régulièrement les entrées et autres événements à partir d'un script et de prendre les mesures appropriées. Par exemple, vous pouvez déplacer un personnage lorsque vous appuyez sur la touche "avant". Une chose importante à retenir lorsque vous manipulez des actions basées sur le temps comme celui-ci est que le framerate du jeu n'est pas constant et que l'intervalle de temps entre les appels de la fonction Update n'est pas constante.

Variables statiques

captureFramerateRalentit le temps de lecture du jeu pour permettre la sauvegarde des captures d'écran entre les frames.
deltaTimeLe temps en secondes qu'il a fallu pour terminer la dernière frame (Lecture seule).
fixedDeltaTimeL'intervalle en secondes auquel la physique et d'autres mis à jour du taux d'images fixes (comme FixedUpdate de MonoBehaviour) sont effectuées.
fixedTimeLe moment où le dernier FixedUpdate a démarré (Lecture seule). C'est le temps en secondes depuis le début du jeu.
fixedUnscaledDeltaTimeL'intervalle timeScale-independent en secondes de la dernière frame fixe à celle actuelle (Lecture seule).
fixedUnscaledTimeLe temps TimeScale-independant du dernier FixedUpdate qui a démarré (Lecture seule). C'est le temps en secondes depuis le début du jeu.
frameCountLe nombre total frames qui sont passées (Lecture seule).
inFixedTimeStepRenvoie la valeur true si elle est appelée à l'intérieur d'un rappel de temps temporel fixe (comme FixedUpdate de MonoBehaviour), sinon renvoie false.
maximumDeltaTimeLe temps maximum qu'une frame peut prendre. La physique et d'autres mis à jour du taux d'images fixes (comme FixedUpdate de MonoBehaviour)
maximumParticleDeltaTimeLe temps maximum qu'une frame peut passer pour les mises à jour des particules. Si la frame prend plus de temps que ça, les mises à jour sont divisées en plusieurs mises à jour plus petites.
realtimeSinceStartupLe temps réel en secondes depuis le début du jeu (Lecture seule).
smoothDeltaTimeUn temps lissé de Time.deltaTime (Lecture seule).
timeLe temps au début de cette frame (Lecture seule). C'est le temps en secondes depuis le début du jeu.
timeScaleL'échelle à laquelle le temps passe. Cela peut être utilisé pour des effets de ralenti.
timeSinceLevelLoadLe temps de cette frame qui a commencé (Lecture seule). C'est le temps en secondes depuis le chargement du dernier niveau.
unscaledDeltaTimeL'intervalle timeScale-independent en secondes depuis la dernière frame à celle actuelle (Lecture seule).
unscaledTimeLe temps timeScale-independent pour cette frame (Lecture seule). C'est le temps en secondes depuis le début du jeu.

Time.captureFramerate

public static int captureFramerate;

Si cette propriété a une valeur non nulle, la mise à jour de la frame se produira à une intervalle de (1.0 / captureFramerate) quel que soit le temps réel et le temps requis pour rendre une frame. Ceci est utile si vous souhaitez capturer une vidéo où vous avez besoin d'une fréquence d'images constante et laisser suffisamment de temps entre les frames pour sauvegarder les captures d'écran.

C#using UnityEngine;
using System.Collections;

// Capture des frames en tant que séquence d'écran. Les images sont
// stockées sous forme de fichiers PNG dans un dossier - ceux-ci peuvent être combinés
// en une vidéo utilisant un logiciel d'utilité d'image (ex : QuickTime Pro).

public class ExampleClass : MonoBehaviour
{
    // Le dossier qui contient les captures d'écran.
    // Si le dossier existe, nous ajouterons des nombres pour créer un dossier vide.
    public string folder = "ScreenshotFolder";
    public int frameRate = 25;
    void Start()
    {
        // Régle le taux de lecture (Le temps réel ne se rapportera pas au temps de jeu après cela).
        Time.captureFramerate = frameRate;

        // Création du dossier
        System.IO.Directory.CreateDirectory(folder);
    }

    void Update()
    {
        // Ajouter le nom du fichier au nom du dossier (Le format est '0005 shot.png"')
        string name = string.Format("{0}/{1:D04} shot.png", folder, Time.frameCount);

        // Capture la capture d'écran vers le fichier spécifié.
        ScreenCapture.CaptureScreenshot(name);
    }
}

Time.deltaTime

public static float deltaTime;

Utilisez cette fonction pour rendre votre taux d'image de jeu indépendant. Si vous ajoutez ou soustrayez à une valeur, vous devriez multiplier avec Time.deltaTime. Lorsque vous multipliez par Time.deltaTime vous exprimez essentiellement : Je souhaite déplacer cet objet de 10 mètres par seconde au lieu de 10 mètres par frame.

Lorsqu'il est appelé à partir de FixedUpdate de MonoBehaviour, il retourne le temps Delta du fixed framerate.

Notez que vous ne devriez pas compter sur Time.deltaTime depuis l'intérieur d'OnGUI car OnGUI peut être appelé plusieurs fois par frame et deltaTime tiendra la même valeur chaque appel, jusqu'à la prochaine frame où il serait à nouveau mis à jour.

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void Update() {
        float translation = Time.deltaTime * 10;
        transform.Translate(0, 0, translation);
    }
}

Time.fixedDeltaTime

public static float fixedDeltaTime;

Pour lire le temps delta, il est recommandé d'utiliser Time.deltaTime à la place, car il renvoie automatiquement le bon temps du delta si vous êtes dans une fonction FixedUpdate ou Update.

Notez que l'intervalle fixedDeltaTime concerne le temps de jeu affecté par timeScale.

Time.fixedTime

public static float fixedTime;

Le temps fixe est mis à jour régulièrement (égal à fixedDeltaTime) jusqu'à ce que la propriété time soit atteinte.

Time.fixedUnscaledDeltaTime

public static float fixedUnscaledDeltaTime;

Pour lire le temps delta unscaled, il est recommandé d'utiliser Time.deltaTime à la place, car il renvoie automatiquement le bon temps du delta unscaled si vous êtes dans une fonction FixedUpdate ou Update.

Contrairement à fixedDeltaTime, cette valeur n'est pas affectée par timeScale.

Time.fixedUnscaledTime

public static float fixedUnscaledTime;

Renvoie la même valeur si elle est appelée plusieurs fois dans une seule frame. Contrairement à fixedTime, cette valeur n'est pas affectée par timeScale.

Time.frameCount

public static int frameCount;

Remarque: frameCount commence une fois que toutes les fonctions Awake sont terminées. La valeur frameCount sera indéfinie pendant les fonctions Awake.

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    private static int lastRecalculation = -1;
    static void RecalculateValue() {
        if (lastRecalculation == Time.frameCount)
            return;
        
    }
}

Time.inFixedTimeStep

public static bool inFixedTimeStep;

Renvoie la valeur true si elle est appelée à l'intérieur d'un rappel de temps temporel fixe (comme FixedUpdate de MonoBehaviour), sinon renvoie false.

Time.maximumDeltaTime

ublic static float maximumDeltaTime;

Ne sera effectué que pour cette durée par frame. Utilisez cette fonction pour éviter que les pics de fréquence de cadence ne se produisent en raison de la combinaison de GarbageCollector et de la physique coûteuse ou d'autres mises à jour de fixed frame.

Si la frame prend plus de temps que la valeur spécifiée, moins de physique et autres mises à jour seront effectuées. Cela ralentira temporairement le gameplay, mais permettra à la fréquence d'images de se contourner en évitant le bégaiement indésirable.

Il est conseillé de maintenir le temps maximum pour la frame entre 1/10ème et 1/3ème de seconde.

Time.maximumParticleDeltaTime

public static float maximumParticleDeltaTime;

Utilisez cette fonction pour équilibrer la précision de la simulation de particules par rapport à votre cible de performance. L'utilisation d'une petite valeur donnera des simulations de particules de meilleure qualité, mais prendra plus de temps de traitement. Les mises à jour de particules seront exécutées plusieurs fois à des intervalles de temps plus petits, si le temps d'image dépasse le seuil fourni.

À l'inverse, une valeur plus élevée garantira que les simulations de particules ne se décomposent pas en plusieurs étapes par frame, ce qui donne la meilleure performance, mais perdra la précision de la simulation lors de l'utilisation de certaines fonctionnalités de simulation de particules plus avancées.

Time.realtimeSinceStartup

public static float realtimeSinceStartup;

Dans presque tous les cas, vous pouvez utiliser Time.time à la place. realtimeSinceStartup renvoie le temps depuis le démarrage, non affecté par Time.timeScale. realtimeSinceStartup augmente toujours pendant que le joueur est en pause (en arrière-plan). L'utilisation de realtimeSinceStartup est utile lorsque vous souhaitez interrompre le jeu en définissant Time.timeScale à zéro, mais souhaitez toujours pouvoir mesurer le temps.

Notez que realtimeSinceStartup retourne le temps indiqué par la minuterie du système. Selon la plate-forme et le matériel, il peut signaler le même temps même dans plusieurs frames consécutives. Si vous divisez quelque chose par la différence de temps, prenez ceci en compte (la différence de temps peut devenir nulle).

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void Example() {
        print(Time.realtimeSinceStartup);
    }
}

Un autre exemple :

C#using UnityEngine;
using System.Collections;

// Un compteur FPS.
// Il calcule les images/seconde sur chaque updateInterval,
// de sorte que l'affichage ne change pas de façon sauvage.
public class ExampleClass : MonoBehaviour
{
    public float updateInterval = 0.5F;
    private double lastInterval;
    private int frames = 0;
    private float fps;
    void Start()
    {
        lastInterval = Time.realtimeSinceStartup;
        frames = 0;
    }

    void OnGUI()
    {
        GUILayout.Label("" + fps.ToString("f2"));
    }

    void Update()
    {
        ++frames;
        float timeNow = Time.realtimeSinceStartup;
        if (timeNow > lastInterval + updateInterval)
        {
            fps = (float)(frames / (timeNow - lastInterval));
            frames = 0;
            lastInterval = timeNow;
        }
    }
}

Time.smoothDeltaTime

public static float smoothDeltaTime;

Un temps lissé de Time.deltaTime (Lecture seule).

Time.time

public static float time;

Renvoie la même valeur si elle est appelée plusieurs fois dans une seule frame. Lorsqu'il est appelé à partir de FixedUpdate de MonoBehaviour, renvoie la propriété fixedTime.

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    public GameObject projectile;
    public float fireRate = 0.5F;
    private float nextFire = 0.0F;
    void Update() {
        if (Input.GetButton("Fire1") && Time.time > nextFire) {
            nextFire = Time.time + fireRate;
            GameObject clone = Instantiate(projectile, transform.position, transform.rotation) as GameObject;
        }
    }
}

Time.timeScale

public static float timeScale;

Lorsque timeScale est à 1.0, le temps passe aussi vite qu'en temps réel. Lorsque timeScale est à 0.5, le temps passe 2 fois plus lentement que le temps réel.

Lorsque timeScale est mis à zéro, le jeu est fondamentalement en pause si toutes vos fonctions sont indépendantes de la fréquence d'images.

À l'exception de realtimeSinceStartup, timeScale affecte toutes les variables de temps et de temps de delta de la classe Time. Si vous réduisez timeScale, il est recommandé de réduire également Time.fixedDeltaTime par la même valeur. Les fonctions FixedUpdate ne seront pas appelées lorsque timeScale est mis à zéro.

C#using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void Update() {
        if (Input.GetButtonDown("Fire1")) {
            if (Time.timeScale == 1.0F)
                Time.timeScale = 0.7F;
            else
                Time.timeScale = 1.0F;
            Time.fixedDeltaTime = 0.02F * Time.timeScale;
        }
    }
}

Time.timeSinceLevelLoad

public static float timeSinceLevelLoad;

Le temps de cette frame qui a commencé (Lecture seule). C'est le temps en secondes depuis le chargement du dernier niveau.

Time.unscaledDeltaTime

public static float unscaledDeltaTime;

Lorsqu'il est appelé à partir de FixedUpdate de MonoBehaviour, retourne le temps Delta de fixed framerate unscaled. Contrairement à deltaTime, cette valeur n'est pas affectée par timeScale.

Time.unscaledTime

public static float unscaledTime;

Lorsqu'il est appelé à partir de l'objet FixedUpdate de MonoBehaviour, il renvoie le temps fixe unscaled. Renvoie la même valeur si elle est appelée plusieurs fois dans une seule frame. Contrairement au time, cette valeur n'est pas affectée par timeScale.

les réactions

Pour laisser un avis, vous devez être inscrit et connecté

Se connecter