Важные классы - Time

Класс Unity Time предоставляет важные базовые свойства, которые позволяют вам работать со значениями, связанными со временем, в вашем проекте.

Эта страница содержит пояснения для некоторых наиболее часто используемых членов класса Time и того, как они соотносятся друг с другом. Вы можете прочитать отдельные описания для каждого члена класса времени на странице справочника сценариев времени.

Класс Time имеет несколько свойств, которые предоставляют вам числовые значения, позволяющие измерять время, прошедшее во время работы вашей игры или приложения. Например:

Time.time возвращает количество времени в секундах с момента начала воспроизведения вашего проекта.
Time.deltaTime возвращает время в секундах, прошедшее с момента последний кадр завершен. Это значение зависит от кадров в секундучастоты, с которой отображаются последовательные кадры в запущенной игре. Подробнее
Просмотр в Словарь (FPS) скорости, с которой работает ваша игра или приложение.

Класс Time также предоставляет вам свойства, которые позволяют вам контролировать и ограничивать время, например:

Time.timeScale управляет скоростью, с которой истекает время. Вы можете прочитать это значение или установить его, чтобы управлять скоростью течения времени, что позволяет создавать эффекты замедления.
Time.fixedDeltaTime управляет интервалом Unity фиксированный временной шагнастраиваемый интервал, не зависящий от частоты кадров, который определяет, когда выполняются физические расчеты и события FixedUpdate(). Подробнее
Смотреть в цикле Словарь (используется для физики, и если вы хотите написать детерминированный код, основанный на времени).
Time.maximumDeltaTime устанавливает верхний предел количества времени, которое система сообщает об истечении с помощью указанных выше свойств «дельта-время».

Переменные и фиксированные временные шаги

В Unity есть две системы отслеживания времени: одна с переменным интервалом времени между каждым шагом, а другая с фиксированным интервалом времени между каждым этапом.

Система с переменным шагом по времени основана на повторяющемся процессе рисования кадра на экране и однократном запуске кода приложения или игры для каждого кадра.

Система с фиксированным временным шагом делает шаг вперед на заранее заданную величину на каждом шаге и не связана с обновлениями визуального кадра. Чаще всего это связано с физической системой, которая работает со скоростью, определяемой фиксированным размером шага по времени, но при необходимости вы также можете выполнять свой собственный код на каждом фиксированном шаге по времени.

Управление переменной частотой кадров

Частота кадров вашей игры или приложения может варьироваться из-за времени, которое требуется для отображения и выполнения кода для каждого кадра. Это зависит от возможностей устройства, на котором он работает, а также от различной сложности отображаемой графики и вычислений, необходимых для каждого кадра. Например, ваша игра может работать с более низкой частотой кадров, когда на экране активны сто персонажей, по сравнению с тем, когда на экране только один. Эту переменную частоту часто называют «кадров в секунду» или FPSСм. шутер от первого лица, кадров в секунду.
См. в Словарь.

Если иное не ограничено вашими настройками качества или пакетом Adaptive Performance, Unity пытается запускайте игру или приложение с максимально возможной частотой кадров. Подробнее о том, что происходит в каждом кадре, можно узнать на диаграмме порядка выполнения в разделе "Игровая логика".

Unity предоставляет метод Update в качестве отправной точки для выполнения собственного кода. каждый кадр. Например, в методе Update вашего игрового персонажа вы можете прочитать пользовательский ввод с джойстика и переместить персонажа вперед на определенную величину. При работе с действиями, основанными на времени, важно помнить, что частота кадров в игре может варьироваться, и поэтому продолжительность времени между вызовами обновления также может быть разной.

Рассмотрите задачу постепенного перемещения объекта вперед, по одному кадру за раз. Сначала может показаться, что можно просто перемещать объект на фиксированное расстояние в каждом кадре:

//C# script example
using UnityEngine;
using System.Collections;

public class ExampleScript : MonoBehaviour {
    public float distancePerFrame;
    
    void Update() {
        transform.Translate(0, 0, distancePerFrame); // this is incorrect
    }
}

Однако с этим кодом при изменении частоты кадров изменяется и видимая скорость объекта. Если игра работает со скоростью 100 кадров в секунду, объект перемещается на distancePerFrame сто раз в секунду. Но если частота кадров упадет до 60 кадров в секунду (скажем, из-за загрузки ЦП), то будет происходить только 60 переходов вперед в секунду, и, следовательно, за то же время будет покрываться меньшее расстояние.

В большинстве случаев это нежелательно, особенно для игр и анимации. Гораздо чаще хочется, чтобы ваши игровые объекты двигались с постоянной и предсказуемой скоростью независимо от частоты кадров. Решение состоит в том, чтобы масштабировать количество движения в каждом кадре по количеству времени, прошедшему в каждом кадре, которое можно прочитать в свойстве Time.deltaTime :

//C# script example
using UnityEngine;
using System.Collections;

public class ExampleScript : MonoBehaviour {
    public float distancePerSecond;
    
    void Update() {
        transform.Translate(0, 0, distancePerSecond * Time.deltaTime);
    }
}

Обратите внимание, что движение теперь задается как distancePerSecond, а не как distancePerFrame. Поскольку частота кадров меняется, размер шага движения будет меняться соответственно, поэтому скорость объекта будет постоянной.

В зависимости от целевой платформы используйте либо Application.targetFrameRate, либо QualitySettings. .vSyncCount, чтобы установить частоту кадров вашего приложения. Дополнительную информацию см. в документации API Application.targetFrameRate.

Фиксированный временной шаг

В отличие от обновления основного кадра, физическая система Unity работает с фиксированным временным шагом, что важно для точности и согласованности симуляции. В начале каждого кадра Unity выполняет столько фиксированных обновлений, сколько необходимо, чтобы соответствовать текущему времени. Подробнее о том, что происходит во время фиксированного цикла обновления, можно узнать на схеме порядка выполнения в разделе "Физические характеристики".

При необходимости вы также можете выполнить свой собственный код синхронно с фиксированным шагом времени. Это чаще всего используется для выполнения вашего собственного кода, связанного с физикой, такого как приложение силы к RigidbodyКомпонент, позволяющий воздействовать на GameObject смоделированной гравитацией и другими силами. Подробнее
См. в Словарь. Unity предоставляет метод FixedUpdate в качестве точки входа для выполнения собственного кода на каждом фиксированном временном шаге. .

Свойство fixedDeltaTime управляет интервалом цикла фиксированного временного шага Unity и указывается в секунды. Например, значение 0,01 означает, что продолжительность каждого фиксированного временного шага составляет одну сотую секунды, поэтому в секунду будет 100 фиксированных временных шагов.

Если частота кадров в вашей игре или приложении выше, чем количество фиксированных временных шагов в секунду, это означает, что продолжительность каждого кадра меньше, чем продолжительность одного фиксированного временного шага. В этом случае Unity выполняет либо ноль, либо одно фиксированное обновление физики за кадр. Например, если фиксированное значение временного шага равно 0,02, будет 50 фиксированных обновлений в секунду. Если ваша игра или приложение будут работать со скоростью 60 кадров в секунду, примерно каждый десятый кадр не будет иметь фиксированного обновления.

Пример, показывающий, как обновление работает со скоростью 60 кадров в секунду, а FixedUpdate — со скоростью 50 обновлений в секунду. Иногда происходит обновление фрейма (отмечено желтым цветом) без соответствующего FixedUpdate.

Если частота кадров в вашей игре или приложении ниже, чем значение фиксированного временного шага, это означает, что продолжительность каждого кадра больше, чем один фиксированный временной шаг. Чтобы учесть это, Unity будет выполнять одно или несколько фиксированных обновлений в каждом кадре, чтобы симуляция физики соответствовала количеству времени, прошедшему с момента последнего кадра. Например, если фиксированное значение временного шага равно 0,01, будет 100 фиксированных обновлений в секунду. Если ваше приложение работает со скоростью 25 кадров в секунду, Until выполняет четыре фиксированных обновления в каждом кадре. Вам может понадобиться такой сценарий, когда более точное моделирование физики важнее, чем высокая частота кадров.

Пример, показывающий, как обновление работает со скоростью 25 кадров в секунду, а FixedUpdate — со скоростью 100 обновлений в секунду. Вы можете видеть четыре события FixedUpdate в течение одного кадра, отмеченные желтым цветом.

Вы можете прочитать или изменить продолжительность фиксированного временного шага в окне Время или из скрипта с помощью Time.fixedDeltaTime свойство.

Примечание. Меньшее значение временного шага означает более частые обновления физики и более точное моделирование, что приводит к более высокой нагрузке на ЦП.

Логика времени Unity

На следующей блок-схеме показана логика, которую Unity использует для подсчета времени в одном кадре, и то, как время, deltaTime, fixedDeltaTime и свойства maximumDeltaTime связаны друг с другом.

Контроль и обработка отклонений во времени

Как описано выше, количество времени, прошедшего между каждым кадром, может различаться.

Вариации прошедшего времени могут быть незначительными. Например, в игре с частотой 60 кадров в секунду фактическое количество кадров в секунду может немного отличаться, поэтому каждый кадр длится от 0,016 до 0,018 секунды. Большие различия могут возникать, когда ваше приложение выполняет тяжелые вычисления или сборку мусора, или когда ресурсы, необходимые для поддержания частоты кадров, используются другим приложением.

В этом разделе описаны следующие свойства:

Каждое из этих свойств имеет собственную страницу документации API сценариев, но их описания и выходные данные могут быть полезны для понимания их правильного использования.

Time.time указывает количество времени, прошедшее с момента запуска проигрывателя, и поэтому обычно постоянно и неуклонно растет. Time.deltaTime указывает количество времени, прошедшее с момента последнего кадра, и поэтому в идеале остается практически постоянным.

Оба этих значения являются субъективными показателями времени, прошедшего в вашем приложении или игре. Это означает, что они учитывают любое масштабирование времени, которое вы применяете. Так, например, вы можете установить Time.timeScale на 0,1 для эффекта замедленного движения (что означает 10% от нормальной скорости воспроизведения). В этой ситуации значение, сообщаемое Time.time, увеличивается на 10% по сравнению с "реальным" временем. Через 10 секунд значение Time.time увеличилось бы на 1. В дополнение к замедлению или ускорению времени в вашем приложении вы можете установить Time.timeScale на ноль, чтобы поставить игру на паузу, и в этом случае метод Update по-прежнему вызывается, но Time.time вообще не увеличивается, и Time.deltaTime равен нулю.

Эти значения также ограничиваются значением свойства Time.maximumDeltaTime. Это означает, что продолжительность любых пауз или изменений частоты кадров, о которых сообщают эти свойства, никогда не превысит maxDeltaTime. Например, если происходит задержка в одну секунду, но для maxDeltaTime задано значение по умолчанию 0,333, Time.time увеличится только на 0,333, а Time.deltaTime будет равно 0,333, несмотря на то, что в реальном мире прошло больше времени.

Немасштабированные версии каждого из этих свойств (Time.unscaledTime и Time.unscaledDeltaTime) игнорируют эти субъективные вариации и ограничения. , и сообщите фактическое время, прошедшее в обоих случаях. Это полезно для всего, что должно реагировать с фиксированной скоростью, даже когда игра идет в замедленном режиме. Примером этого является UI(пользовательский интерфейс) Позволяет пользователю взаимодействовать с вашим приложением. Подробнее
См. в Словарь анимацию взаимодействия.

В таблице ниже показан пример 16 кадров, проходящих один за другим, с одной большой задержкой, возникающей на полпути, в одном кадре. На этих рисунках показано, как различные свойства класса Time сообщают об этом большом изменении частоты кадров и реагируют на него.

Кадр	немасштабированное время	время	немасштабированное дельта-время	дельта-время	smoothDeltaTime
1	0.000	0.000	0.018	0.018	0.018
2	0.018	0.018	0.018	0.018	0.018
3	0.036	0.036	0.018	0.018	0.018
4	0.054	0.054	0.018	0.018	0.018
5	0.071	0.071	0.017	0.017	0.018
6	0.089	0.089	0.018	0.018	0.018
7	0.107	0.107	0.018	0.018	0.018
8 (a)	1.123 (b)	0.440 (c)	1.016 (d)	0.333 (e)	0.081 (f)
9	1.140	0.457	0.017	0.017	0.066
10	1.157	0.474	0.017	0.017	0.056
11	1.175	0.492	0.018	0.018	0.049
12	1.193	0.510	0.018	0.018	0.042
13	1.211	0.528	0.018	0.018	0.038
14	1.229	0.546	0.018	0.018	0.034
15	1.247	0.564	0.018	0.018	0.031
16	1.265	0.582	0.018	0.018	0.028

Кадры с 1 по 7 воспроизводятся с постоянной скоростью примерно 60 кадров в секунду. Вы можете видеть, что как «время», так и «немасштабированное время» постоянно увеличиваются вместе, что указывает на то, что для параметра timeScale в этом примере установлено значение 1.

Затем в кадре 8 (a) происходит большая задержка чуть более одной секунды. Это может произойти, когда существует конкуренция за ресурсы. Например, код в приложении блокирует основной процесс, пока тот загружает с диска большой объем данных.

Когда происходит задержка кадра, превышающая значение maxDeltaTime, Unity ограничивает значение, сообщаемое deltaTime, и количество, добавляемое к текущему время. Цель этого ограничения — избежать нежелательных побочных эффектов, которые могут возникнуть, если временной шаг превысит это значение. Если бы не было ограничений, то объект, движение которого масштабировалось deltaTime, мог бы «пролезать» через стену в игре во время всплеска частоты кадров, потому что теоретически не было бы ограничения на то, как далеко объект может двигаться за один кадр. к следующему, чтобы он мог прыгать с одной стороны препятствия на другое в одном кадре, вообще не пересекаясь с ним.

Вы можете настроить значение maxDeltaTime в окне Время, где оно помечено как Максимально допустимый временной шаг, а также с помощью Свойство Time.maximumDeltaTime.

Максимальное значение DeltaTime по умолчанию составляет одну треть секунды (0,3333333). Это означает, что в игре, где движение контролируется deltaTime, перемещение объекта от одного кадра к другому ограничено расстоянием, которое он может преодолеть за треть секунды, независимо от того, сколько времени фактически прошло с момента предыдущего кадра.

Глядя на данные из приведенной выше таблицы в виде графика, можно визуализировать, как эти свойства времени ведут себя по отношению друг к другу:

Вы можете видеть выше, в кадре 8, что unscaledDeltaTime (d) и deltaTime (e) отличаются тем, сколько времени они сообщают об истекшем времени. Хотя между кадрами 7 и 8 прошла целая секунда реального времени, deltaTime сообщает только 0,333 секунды. Это связано с тем, что значение deltaTime ограничено значением maximumDeltaTime.

Аналогично, unscaledTime (b) увеличилось примерно на целую секунду, потому что было добавлено истинное (нефиксированное) значение, тогда как время (c) увеличилось только на меньшее фиксированное значение. Значение time не соответствует реальному прошедшему времени, а вместо этого ведет себя так, как если бы задержка составляла maximumDeltaTime по продолжительности.

Свойство Time.smoothDeltaTime сообщает приблизительное значение последних значений deltaTime со всеми изменениями, сглаженными в соответствии с алгоритмом. Это еще один метод, позволяющий избежать нежелательно больших шагов или колебаний в движении или других вычислениях, основанных на времени. В частности, те, которые находятся ниже порога, установленного maximumDeltaTime. Алгоритм сглаживания не может предсказать будущие изменения, но он постепенно адаптирует сообщаемое значение, чтобы сгладить изменения в недавно истекших значениях дельта-времени, так что среднее сообщаемое время остается примерно равным фактическому количеству прошедшего времени.

Изменение времени и физическая система

Значение maximumDeltaTime также влияет на систему физики. Физическая система использует значение fixedTimestep, чтобы определить, сколько времени моделировать на каждом шаге. Unity старается поддерживать симуляцию физики в актуальном состоянии с учетом прошедшего времени и, как упоминалось выше, иногда выполняет несколько обновлений физики за кадр. Однако, если физическая симуляция отстает слишком сильно, например, из-за каких-то сложных вычислений или какой-либо задержки, физической системе может потребоваться большое количество шагов, чтобы догнать текущее время. Это большое количество шагов само по себе может привести к дальнейшему замедлению.

Чтобы избежать этой циклической обратной связи замедления из-за попытки наверстать упущенное, значение maxDeltaTime также действует как ограничение на количество времени, которое физическая система будет моделировать между любыми двумя заданными кадрами.

Если для обработки обновления кадра требуется больше времени, чем maxDeltaTime, физический движоксистема, которая имитирует аспекты физических систем, чтобы объекты могут правильно ускоряться и подвергаться воздействию столкновений, гравитации и других сил. Подробнее
См. Словарь не будет пытаться имитировать любое время за пределами maxDeltaTime, а вместо этого позволяет обработке кадров наверстать упущенное. Как только обновление кадра завершено, физика возобновляется, как будто с момента ее остановки не прошло времени. В результате физические объекты не будут двигаться идеально в реальном времени, как обычно, а будут немного замедлены. Однако физические «часы» по-прежнему будут отслеживать их, как если бы они двигались нормально. Замедление физического времени обычно незаметно и часто является приемлемым компромиссом с производительностью игрового процесса.

Шкала времени

Для специальных временных эффектов, таких как замедленное движение, иногда бывает полезно замедлить течение игрового времени, чтобы анимация и расчеты на основе времени в вашем коде происходили медленнее. Кроме того, иногда вам может понадобиться полностью остановить игровое время, например, когда игра поставлена на паузу. В Unity есть свойство Time Scale, которое определяет, насколько быстро игровое время течет по отношению к реальному времени. Если вы установите шкалу на 1,0, ваше игровое время будет соответствовать реальному времени. Значение 2,0 заставляет время проходить в Unity в два раза быстрее (т. е. действие будет ускорено), а значение 0,5 замедляет игровой процесс вдвое. Нулевое значение полностью остановит ваше игровое время. Обратите внимание, что временная шкала на самом деле не замедляет выполнение, а вместо этого изменяет временной шаг, сообщаемый функциям Update и FixedUpdate, с помощью Time.deltaTime и Time.fixedDeltaTime. Ваша функция Update может вызываться так же часто, когда вы уменьшаете шкалу времени, но значение deltaTime для каждого кадра будет меньше. Шкала времени не влияет на другие функции скрипта, поэтому вы можете, например, отобразить графический интерфейс с обычным взаимодействием, когда игра приостановлена.

Окно Время имеет свойство, позволяющее задавать шкалу времени глобально, но обычно полезнее задавать значение из скрипта с помощью ScriptRef:Time-timeScale свойство:

//C# script example
using UnityEngine;
using System.Collections;

public class ExampleScript : MonoBehaviour {
    void Pause() {
        Time.timeScale = 0;
    }
    
    void Resume() {
        Time.timeScale = 1;
    }
}

Захват частоты кадров

Особым случаем тайм-менеджмента является запись игрового процесса в виде видео. Поскольку задача сохранения изображений экрана занимает значительное время, нормальная частота кадров в игре снижается, а видео не отражает реальную производительность игры.

Чтобы улучшить внешний вид видео, используйте свойство Capture Framerate. Значение свойства по умолчанию равно 0 для незаписанного игрового процесса. Для записи. Когда вы устанавливаете значение свойства, отличное от нуля, время игры замедляется, а обновления кадров выпускаются через точные регулярные интервалы. Интервал между кадрами равен 1 / Time.captureFramerate, поэтому, если вы установите значение 5,0, обновления будут происходить каждую пятую секунды. Поскольку требования к частоте кадров эффективно снижены, у вас есть время с помощью функции «Обновление», чтобы сохранить снимки экрана или выполнить другие действия:

//C# script example
using UnityEngine;
using System.Collections;

public class ExampleScript : MonoBehaviour {
    // Capture frames as a screenshot sequence. Images are
    // stored as PNG files in a folder - these can be combined into
    // a movie using image utility software (eg, QuickTime Pro).
    // The folder to contain our screenshots.
    // If the folder exists we will append numbers to create an empty folder.
    string folder = "ScreenshotFolder";
    int frameRate = 25;
        
    void Start () {
        // Set the playback frame rate (real time will not relate to game time after this).
        Time.captureFramerate = frameRate;
        
        // Create the folder
        System.IO.Directory.CreateDirectory(folder);
    }
    
    void Update () {
        // Append filename to folder name (format is '0005 shot.png"')
        string name = string.Format("{0}/{1:D04} shot.png", folder, Time.frameCount );
        
        // Capture the screenshot to the specified file.
        Application.CaptureScreenshot(name);
    }
}

Использование этой техники улучшает качество видео, но может сильно усложнить игру. Попробуйте разные значения Time.captureFramerate, чтобы найти хороший баланс.

Вы можете отблагодарить автора, за перевод документации на русский язык. ₽ Спасибо