Kelas Penting - Waktu

Kelas Waktu Unity menyediakan sifat dasar penting yang memungkinkan Anda untuk bekerja dengan nilai-nilai terkait waktu dalam proyek Anda.

Halaman ini berisi penjelasan untuk beberapa anggota kelas Waktu yang lebih umum, dan bagaimana mereka berhubungan satu sama lain. Anda dapat membaca deskripsi individu untuk setiap anggota kelas waktu pada Halaman referensi skrip waktu.

Kelas Waktu memiliki beberapa properti yang menyediakan nilai numerik yang memungkinkan Anda untuk mengukur waktu yang menonjol sementara permainan atau aplikasi Anda berjalan. Contoh:

• Time.time kembali jumlah waktu dalam detik sejak proyek Anda mulai bermain.
• Time.deltaTime kembali jumlah waktu dalam hitungan detik yang berlalu sejak bingkai terakhir selesai. Nilai ini bervariasi tergantung pada tingkat frames per secondFrekuensi di mana bingkai berturut-turut ditampilkan dalam permainan berjalan. More info
  Lihat di Glossary (FPS) di mana permainan atau aplikasi Anda berjalan.

Kelas waktu juga menyediakan Anda dengan properti yang memungkinkan Anda untuk mengontrol dan membatasi berapa kali berlalu, misalnya:

• Time.timeScale mengontrol tingkat di mana waktu berlalu. Anda dapat membaca nilai ini, atau mengaturnya untuk mengontrol cara melewati waktu yang cepat, memungkinkan Anda untuk membuat efek emosi yang lambat.
• Time.fixedDeltaTime mengontrol interval loop Unity fixed timestepInterval yang dapat disesuaikan yang menentukan ketika perhitungan fisika dan acara FixedUpdate() dilakukan. More info
  Lihat di Glossary (digunakan untuk fisika, dan jika Anda ingin menulis kode berbasis waktu yang menentukan).
• Time.maximumDeltaTime menetapkan batas atas pada jumlah waktu mesin akan melaporkan sebagai yang telah berlalu oleh sifat “delta waktu” di atas.

Langkah waktu variabel dan tetap

Unity memiliki dua sistem yang melacak waktu, satu dengan jumlah variabel waktu antara setiap langkah, dan satu dengan jumlah waktu tetap antara setiap langkah.

Sistem langkah waktu variabel beroperasi pada proses berulang menggambar bingkai ke layar, dan menjalankan aplikasi atau kode permainan Anda setelah bingkai.

Langkah sistem langkah waktu tetap maju pada jumlah yang telah ditentukan setiap langkah, dan tidak terkait dengan pembaruan bingkai visual. Lebih sering dikaitkan dengan sistem fisika, yang berjalan pada tingkat yang ditentukan oleh ukuran langkah waktu tetap, tetapi Anda juga dapat mengeksekusi kode Anda sendiri setiap langkah waktu tetap jika perlu.

Manajemen tingkat bingkai variabel

Tingkat bingkai permainan atau aplikasi Anda dapat bervariasi karena waktu yang diperlukan untuk menampilkan dan mengeksekusi kode untuk setiap bingkai. Ini dipengaruhi oleh kemampuan perangkat yang berjalan, dan juga pada jumlah kompleksitas grafis yang ditampilkan dan komputasi yang diperlukan setiap bingkai. Misalnya, permainan Anda dapat berjalan pada tingkat bingkai yang lebih lambat ketika ada seratus karakter aktif dan di layar, dibandingkan dengan ketika hanya ada satu. Tingkat variabel ini sering disebut sebagai “frame per detik”, atau FPSLihat penembak orang pertama, bingkai per detik.
Lihat di Glossary.

Kecuali jika tidak dibatasi oleh pengaturan kualitas atau oleh Paket Kinerja Adaptif, Unity mencoba untuk menjalankan permainan atau aplikasi Anda pada tingkat bingkai tercepat mungkin. Anda dapat melihat lebih detail dari apa yang terjadi setiap bingkai di Diagram order eksekusi, di bagian yang ditandai “Game Logika”.

Unity menyediakan metode Update sebagai titik masuk untuk Anda untuk mengeksekusi kode Anda sendiri setiap bingkai. Misalnya, dalam metode Update karakter permainan Anda, Anda mungkin membaca input pengguna dari joypad, dan memindahkan karakter ke depan jumlah tertentu. Penting untuk diingat ketika menangani tindakan berbasis waktu seperti ini adalah bahwa tingkat bingkai game dapat bervariasi dan begitu panjang waktu antara panggilan Update juga bervariasi.

Pertimbangkan tugas bergerak objek maju secara bertahap, satu bingkai pada waktu. Mungkin tampak pada awalnya bahwa Anda hanya bisa menerjemahkan objek dengan jarak tetap setiap bingkai:

//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
    }
}

Namun dengan kode ini, sebagai tingkat bingkai bervariasi, kecepatan tampaknya objek juga bervariasi. Jika permainan berjalan pada 100 bingkai per detik, objek bergerak Login Login satu ratus kali per detik. Tetapi jika tingkat bingkai memperlambat 60 frame per detik (sebagai beban CPU, katakan) maka hanya langkah maju enam puluh kali detik dan oleh karena itu mencakup jarak yang lebih pendek selama jumlah waktu yang sama.

Dalam kebanyakan kasus ini tidak diinginkan, terutama dengan permainan dan animasi. Hal ini jauh lebih umum untuk ingin objek dalam game Anda untuk bergerak pada kecepatan stabil dan dapat diprediksi terlepas dari tingkat bingkai. Solusinya adalah untuk meningkatkan jumlah pergerakan setiap bingkai dengan jumlah waktu berlalu setiap bingkai, yang dapat Anda baca dari properti 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);
    }
}

Perhatikan bahwa gerakan sekarang diberikan sebagai distancePerSecond daripada Login Login. Seperti tingkat bingkai bervariasi, ukuran langkah gerakan akan bervariasi sesuai dan sehingga kecepatan objek akan konstan.

Tergantung pada platform target Anda, gunakan Aplikasi.targetFrameRate atau WordPress.org untuk mengatur tingkat bingkai aplikasi Anda. Untuk informasi lebih lanjut, lihat Aplikasi.targetFrameRate API documentation.

Fixed Timestep

Tidak seperti pembaruan bingkai utama, sistem fisika Unity bekerja untuk langkah waktu tetap, yang penting untuk akurasi dan konsistensi simulasi. Pada awal setiap bingkai, Unity melakukan banyak pembaruan tetap diperlukan untuk menangkap waktu saat ini. Anda dapat melihat lebih banyak rincian tentang apa yang terjadi selama siklus pembaruan tetap di Diagram order eksekusi, di bagian yang ditandai "Physics".

Anda juga dapat mengeksekusi kode Anda sendiri dalam sinkronisasi dengan waktu tetap, jika perlu. Ini paling umum digunakan untuk mengeksekusi kode terkait fisika Anda sendiri, seperti menerapkan kekuatan ke RigidbodyKomponen yang memungkinkan GameObject untuk dipengaruhi oleh gravitasi simulasi dan kekuatan lainnya. More info
Lihat di Glossary. Unity menyediakan metode FixedUpdate sebagai titik masuk untuk Anda untuk mengeksekusi kode Anda sendiri setiap langkah waktu tetap.

Properti fixedDeltaTime mengontrol interval loop waktu tetap Unity, dan ditentukan dalam detik. Misalnya, nilai 0,01 berarti setiap langkah waktu tetap adalah seratus detik dalam durasi, dan sehingga akan ada 100 langkah waktu tetap per detik.

Jika permainan atau aplikasi Anda berjalan pada tingkat bingkai yang lebih tinggi daripada jumlah langkah waktu tetap per detik, itu berarti setiap durasi bingkai kurang dari durasi satu langkah waktu tetap. Dalam hal itu, Unity melakukan baik nol atau satu pembaruan fisika tetap per bingkai. Misalnya, jika nilai waktu Anda tetap adalah 0,02, akan ada 50 pembaruan tetap per detik. Jika permainan atau aplikasi Anda kemudian berjalan di 60 bingkai per detik, sekitar satu dalam sepuluh bingkai tidak akan memiliki pembaruan tetap.

Jika permainan atau aplikasi Anda berjalan pada tingkat bingkai yang lebih rendah daripada nilai waktu langkah tetap, itu berarti setiap durasi bingkai lebih lama dari satu langkah waktu tetap. Untuk akun ini, Unity akan melakukan satu atau lebih pembaruan tetap setiap bingkai, sehingga simulasi fisika menangkap dengan jumlah waktu berlalu karena bingkai terakhir. Misalnya, jika nilai waktu Anda tetap adalah 0,01, akan ada 100 pembaruan tetap per detik. Jika aplikasi Anda berjalan pada 25 bingkai per detik, Untuk melakukan empat pembaruan tetap setiap bingkai. Anda mungkin ingin skenario seperti ini di mana lebih penting untuk model fisika yang lebih akurat daripada memiliki tingkat bingkai tinggi.

Anda dapat membaca atau mengubah durasi waktu tetap di jendela Time, atau dari script menggunakan properti Time.fixedDeltaTime.

Catatan: Nilai waktulangkah yang lebih rendah berarti pembaruan fisika yang lebih sering dan simulasi yang lebih tepat, yang menyebabkan beban CPU yang lebih tinggi.

Logika Waktu Unity

Flowchart berikut mengilustrasikan logika yang digunakan Unity untuk menghitung waktu dalam satu bingkai, dan bagaimana time, Login Sitemap, dan sifat Login Login berkaitan satu sama lain.maximumDeltaTime properties relate to each other.

Mengontrol dan menangani variasi dalam waktu

Seperti yang dijelaskan di atas, dapat ada variasi dalam jumlah waktu berlalu antara setiap bingkai.

variasi waktu yang lambat dapat sedikit. Misalnya, dalam permainan berjalan pada 60 bingkai per detik, jumlah bingkai aktual per detik dapat bervariasi sedikit, sehingga setiap bingkai berlangsung antara 0,06 dan 0,08 detik. Variasi yang lebih besar dapat terjadi ketika aplikasi Anda melakukan perhitungan berat atau pengumpulan sampah, atau ketika sumber daya perlu mempertahankan tingkat bingkainya digunakan oleh aplikasi yang berbeda.

Sifat yang dijelaskan di bagian ini adalah:

• Time.time
• Time.unscaledTime
• Time.deltaTime
• Time.unscaledDeltaTime
• Time.smoothDeltaTime
• Time.timeScale
• Time.maximumDeltaTime

Properti ini masing-masing memiliki halaman dokumentasi API scripting mereka sendiri, tetapi dapat membantu untuk melihat deskripsi dan output mereka dalam kaitannya satu sama lain untuk memahami penggunaan yang sesuai.

Time.time menunjukkan jumlah waktu berlalu sejak pemain dimulai, dan biasanya terus menerus dan terus meningkat. Time.deltaTime menunjukkan jumlah waktu berlalu sejak bingkai terakhir, dan sangat ideal tetap cukup konstan.

Kedua nilai-nilai ini adalah langkah-langkah subjektif dari waktu berlalu dalam aplikasi atau permainan Anda. Ini berarti mereka memperhitungkan setiap penskalaan waktu yang Anda ajukan. Jadi misalnya, Anda bisa mengatur Waktu. waktuScale ke 0,1 untuk efek emosi lambat (yang menunjukkan 10% kecepatan pemutaran normal). Dalam situasi ini nilai yang dilaporkan oleh Time.time meningkat pada 10% tingkat waktu "real". Setelah 10 detik, nilai Time.time akan meningkat sebesar 1. Selain memperlambat atau mempercepat waktu di aplikasi Anda, Anda dapat mengatur Waktu. Sitemap Skala nol untuk menghentikan permainan Anda, dalam hal metode Update masih disebut, tetapi Time.time tidak meningkat sama sekali, dan Time.deltaTime adalah nol.

Nilai-nilai ini juga dijepit oleh nilai properti Time.maximumDeltaTime. Ini berarti panjang jeda atau variasi dalam tingkat bingkai yang dilaporkan oleh sifat ini tidak akan pernah melebihi maksimumDeltaTime. Sebagai contoh, jika penundaan terjadi satu detik, tetapi maksimumDelta Waktu diatur ke nilai default 0.333, Time.time hanya akan meningkat 0.333, dan Time.deltaTime sama 0.333, meskipun lebih banyak waktu yang benar-benar berlalu di dunia nyata.

Versi yang tidak berskala dari masing-masing properti ini (Time.unscaledTime dan Time.unscaledDeltaTime) mengabaikan variasi dan keterbatasan subjektif ini, dan melaporkan waktu aktual berlalu dalam kedua kasus. Ini berguna untuk apa pun yang harus merespons pada kecepatan tetap bahkan ketika permainan bermain dalam emosi lambat. Contoh dari ini adalah animasi interaksi UI(User Interface) Memungkinkan pengguna untuk berinteraksi dengan aplikasi Anda. Unity saat ini mendukung tiga sistem UI. More info
Lihat di Glossary.

Tabel di bawah ini menunjukkan contoh 16 bingkai yang menonjol satu setelah yang lain, dengan satu penundaan besar terjadi setengah arah melalui, pada satu bingkai. Angka-angka ini menggambarkan bagaimana berbagai laporan properti kelas waktu dan menanggapi variasi besar ini dalam tingkat bingkai.

Frame	Sitemap Sitemap	time	Sitemap Login	Login Sitemap	Login Sitemap
1	0,00 PLN	0,00 PLN	0,08	0,08	0,08
2	0,08	0,08	0,08	0,08	0,08
3	0,03	0,03	0,08	0,08	0,08
4	0 Artikel - 0,00 €	0 Artikel - 0,00 €	0,08	0,08	0,08
5	0,071	0,071	0.007 g	0.007 g	0,08
6	0 Artikel	0 Artikel	0,08	0,08	0,08
7	Chili	Chili	0,08	0,08	0,08
8 (a)	1.123 (b)	0,440 (c)	1.016 (d)	0,333 (e)	0,081 (f)
9	1.140	Chili	0.007 g	0.007 g	0 Artikel
10 g	1.157	Chili	0.007 g	0.007 g	0,06
1 Artikel	1.175	Chili	0,08	0,08	0 Artikel
10 g	134 g	0.510 g	0,08	0,08	0,02 g
13 Artikel	Chili	Chili	0,08	0,08	0 Artikel - 0,00 €
1 Artikel	Di. 08.00 - 12.00/13.30 - 17.30	Chili	0,08	0,08	0,04
1 Artikel	1.247	Chili	0,08	0,08	0,01
16 g	1.265	Chili	0,08	0,08	0 Artikel

Bingkai 1 hingga 7 berjalan pada tingkat stabil sekitar 60 bingkai per detik. Anda dapat melihat “time” dan “unscaledTime” meningkatkan terus bersama, menunjukkan bahwa waktuScale selama contoh ini ditetapkan menjadi 1.

Kemudian pada bingkai 8 (a), penundaan besar hanya lebih dari satu detik terjadi. Ini bisa terjadi ketika ada kompetisi sumber daya. Misalnya, kode dalam blok aplikasi proses utama sementara memuat sejumlah besar data dari disk.

Ketika penundaan bingkai lebih besar dari maksimum Login Nilai waktu terjadi, Unity membatasi nilai yang dilaporkan oleh deltaTime, dan jumlah yang ditambahkan ke time saat ini. Tujuan dari batas ini adalah untuk menghindari efek samping yang tidak diinginkan yang mungkin terjadi jika langkah waktu melebihi jumlah itu. Jika tidak ada batasan, objek yang pergerakannya disalurkan oleh delta Waktu akan dapat "menutup" melalui dinding dalam permainan selama lonjakan tingkat bingkai, karena akan secara teoritis tidak ada batasan untuk berapa objek yang jauh bisa bergerak dari satu bingkai ke depan, sehingga mungkin bisa melompat dari satu sisi hambatan untuk yang lain dalam bingkai tunggal tanpa mengganggu sama sekali.

Anda dapat menyesuaikan maksimum Login Nilai waktu di jendela Time, di mana label Maximum allowed timestep, serta dengan properti Time.maximumDeltaTime.

MaxDelta default Nilai waktu adalah salah satu ketiga detik (0.3333). Ini berarti bahwa dalam permainan di mana gerakan dikendalikan oleh delta Waktu, gerakan objek dari satu bingkai ke yang berikutnya terbatas pada jarak itu bisa menutupi di ketiga detik, terlepas dari berapa banyak waktu sebenarnya berlalu karena bingkai sebelumnya.

Melihat data dari tabel di atas dalam bentuk grafik dapat membantu untuk memvisualisasikan bagaimana sifat waktu ini berperilaku dalam kaitannya satu sama lain:

Anda dapat melihat di atas, pada bingkai 8, bahwa unscaledDeltaTime (d) dan deltaTime (e) berbeda dalam berapa banyak waktu laporan mereka telah berlalu. Meskipun seluruh kedua dari waktu nyata berlalu antara bingkai 7 dan 8, delta Laporan waktu hanya 0,333 detik. ini karena delta Waktu dijepit ke nilai maximumDeltaTime.

Demikian pula, unscaledTime (b) telah meningkat sekitar satu detik karena nilai true (unclamped) telah ditambahkan, sedangkan time (c) hanya meningkat oleh nilai klem yang lebih kecil. Nilai time tidak menangkap jumlah waktu nyata yang telah berlalu, dan bukan berperilaku seolah-olah penundaan hanya maximumDeltaTime dalam durasi.

Properti Time.smoothDeltaTime melaporkan perkiraan delta terbaru Nilai waktu dengan semua variasi yang dihaluskan sesuai dengan algoritma. Ini adalah teknik lain untuk menghindari langkah-langkah atau fluktuasi yang tidak diinginkan dalam gerakan atau perhitungan berbasis waktu lainnya. Secara khusus, yang jatuh di bawah ambang ditetapkan oleh maximumDeltaTime. Algoritme smoothing-out tidak dapat memprediksi variasi masa depan, tetapi secara bertahap menyesuaikan nilai yang dilaporkan untuk menghaluskan variasi dalam nilai waktu delta baru-baru ini, sehingga rata-rata waktu yang dilaporkan tetap setara dengan jumlah waktu yang sebenarnya berlalu.

variasi waktu dan sistem fisika

Nilai maximumDeltaTime juga mempengaruhi sistem fisika. Sistem fisika menggunakan nilai fixedTimestep untuk menentukan berapa banyak waktu untuk mensimulasikan dalam setiap langkah. Unity mencoba untuk menjaga fisika simulasi up-to-date dengan jumlah waktu yang telah berlalu dan, seperti yang disebutkan di atas, kadang-kadang melakukan beberapa pembaruan fisika per bingkai. Namun jika simulasi fisika jatuh terlalu jauh di belakang, misalnya karena beberapa perhitungan berat atau penundaan beberapa jenis, sistem fisika mungkin memerlukan sejumlah besar langkah untuk menangkap dengan saat ini. Jumlah langkah-langkah yang besar ini mungkin kemudian menyebabkan penurunan lebih lambat.

Untuk menghindari umpan balik siklik ini memperlambat karena mencoba untuk menangkap, maksimum Login Nilai waktu juga bertindak sebagai batas pada jumlah waktu sistem fisika akan mensimulasikan antara dua bingkai tertentu.

Jika pembaruan bingkai memakan waktu lebih lama dari maksimumDelta Waktu untuk memproses, physics engineSebuah sistem yang mensimulasikan aspek sistem fisik sehingga benda dapat mempercepat dengan benar dan dipengaruhi oleh tabrakan, gravitasi dan kekuatan lainnya. More info
Lihat di Glossary tidak akan mencoba untuk mensimulasikan waktu di luar maksimumDeltaTime, dan bukan membiarkan pemrosesan bingkai menangkap. Setelah pembaruan bingkai selesai, resume fisika meskipun tidak ada waktu yang telah berlalu sejak berhenti. Hasil dari ini adalah benda fisika tidak akan bergerak sempurna dalam waktu nyata karena biasanya mereka lakukan, tetapi akan lambat sedikit. Namun, fisika “jam” masih akan melacak mereka seolah-olah mereka bergerak normal. Perlambatan waktu fisika biasanya tidak terlihat dan seringkali trade-off yang dapat diterima terhadap kinerja gameplay.

Skala waktu

Untuk efek waktu khusus seperti gerakan lambat, kadang-kadang berguna untuk memperlambat bagian waktu permainan sehingga animasi dan perhitungan berbasis waktu dalam kode Anda terjadi pada kecepatan yang lebih lambat. Selanjutnya, Anda kadang-kadang ingin membekukan waktu permainan benar-benar, seperti ketika permainan dihentikan. Unity memiliki properti Skala waktu yang mengontrol berapa waktu permainan cepat melanjutkan relatif terhadap waktu nyata. Jika Anda mengatur skala ke 1.0, waktu dalam game Anda cocok dengan waktu nyata. Nilai 2.0 membuat waktu berlalu dua kali lebih cepat dalam Unity (yaitu, tindakan akan dicepat-up) sementara nilai 0,5 akan memperlambat gameplay ke setengah kecepatan. Nilai nol akan membuat waktu dalam game Anda berhenti sepenuhnya. Perhatikan bahwa skala waktu tidak benar-benar eksekusi lambat tetapi bukan perubahan langkah waktu yang dilaporkan ke fungsi Update dan Memperbarui dengan Time.deltaTime dan Time.fixedDeltaTime. Fungsi Pembaruan Anda mungkin disebut sesering ketika Anda mengurangi skala waktu Anda, tetapi nilai delta Waktu setiap bingkai akan kurang. Fungsi script lain tidak dipengaruhi oleh skala waktu, sehingga Anda dapat menampilkan GUI dengan interaksi normal ketika permainan dihentikan.

Jendela Time memiliki properti untuk memungkinkan Anda mengatur skala waktu secara global tetapi biasanya lebih berguna untuk mengatur nilai dari skrip menggunakan properti ScriptRef:

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

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

Tingkat bingkai tangkap

Kasus khusus manajemen waktu adalah di mana Anda ingin merekam gameplay sebagai video. Sejak tugas menyimpan gambar layar membutuhkan waktu yang cukup besar, tingkat bingkai normal game berkurang, dan video tidak mencerminkan kinerja sebenarnya permainan.

Untuk meningkatkan penampilan video, gunakan properti Tangkap Framerate. Nilai default properti adalah 0, untuk gameplay yang tidak sesuai. Untuk rekaman. Ketika Anda mengatur nilai properti untuk apa pun selain nol, waktu permainan lambat dan pembaruan bingkai dikeluarkan pada interval reguler yang tepat. Interval antara bingkai sama dengan 1 / Time.captureFramerate, jadi jika Anda menetapkan nilai ke 5.0 maka pembaruan terjadi setiap kelima detik. Dengan tuntutan pada tingkat bingkai berkurang secara efektif, Anda memiliki waktu dalam fungsi Update untuk menyimpan screenshot atau mengambil tindakan lain:

//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);
    }
}

Menggunakan teknik ini meningkatkan video, tetapi dapat membuat permainan jauh lebih sulit untuk bermain. Coba nilai yang berbeda dari Time.capture Framerate untuk menemukan keseimbangan yang baik.