Resolusi dinamis

Resolusi dinamis adalah pengaturan CameraKomponen yang menciptakan gambar sudut pandang tertentu di tempat kejadian Anda. Output ditarik ke layar atau ditangkap sebagai tekstur. More info
Lihat di Glossary yang memungkinkan Anda untuk meningkatkan target render individu secara dinamis, untuk mengurangi beban kerja pada GPU. Dalam kasus di mana tingkat bingkai aplikasi mengurangi, Anda dapat secara bertahap meningkatkan resolusi untuk mempertahankan tingkat bingkai yang konsisten. Unity memicu penskalaan ini jika data kinerja menunjukkan bahwa tingkat bingkai adalah tentang penurunan sebagai akibat dari penerapan GPU-bound. Anda juga dapat memicu penskalaan secara manual dengan mengempurnakan bagian yang sangat intensif dari aplikasi dan mengendalikan penskalaan melalui skrip. Jika diskalakan secara bertahap, dynamic resolution bisa hampir tidak berbunyi.

Kompatibilitas pipa Render

Dukungan resolusi dinamis tergantung pada penggunaan proyek Anda render pipaRangkaian operasi yang mengambil isi dari Adegan, dan menampilkannya di layar. Unity memungkinkan Anda memilih dari pipa render yang dibangun sebelumnya, atau menulis sendiri. More info
Lihat di Glossary.

Feature	Built-in Render Pipeline	Universal Render Pipeline (URP)	High Definition Render Pipeline (HDRP)
Dynamic resolution	G (1)	G (1)	Promo (2)

Notes:

Pipa Render Built-in, dan resolusi dinamis dukungan Pipa Render Universal (URP) sebagaimana dijelaskan dalam dokumen ini.
Definisi Tinggi Render Pipeline (HDRP) mendukung resolusi dinamis, tetapi Anda mengaktifkan dan menggunakannya dengan cara yang berbeda. Untuk informasi tentang resolusi dinamis di HDRP, lihat.

Platform yang didukung

Unity mendukung resolusi dinamis pada iOS, macOS dan tvOS (Metal only), Android (Vulkan only), Windows Standalone dan UWP (DirectX 12 only).

Dampak pada target render

Dengan resolusi dinamis, Unity tidak mengandalkan target render. Secara konseptual, skala Unity target render; Namun, pada kenyataannya, Unity menggunakan aliasing, dan target render berskala hanya menggunakan bagian kecil dari target render asli. Mengalokasikan target render pada resolusi penuh mereka, dan kemudian sistem resolusi dinamis mengukur mereka ke bawah dan kembali lagi, menggunakan bagian dari target asli bukan menemukan target baru.

Target render Scaling

Dengan resolusi dinamis, target render memiliki bendera DynamicallyScalable. Anda dapat mengatur ini untuk menyatakan apakah Unity harus mengukur render textureJenis Tekstur khusus yang diciptakan dan diperbarui pada runtime. Untuk menggunakannya, pertama membuat Tekstur Render baru dan menunjuk salah satu Kamera Anda untuk membuatnya. Kemudian Anda dapat menggunakan Tekstur Render dalam Bahan seperti Tekstur biasa. More info
Lihat di Glossary ini sebagai bagian dari proses resolusi dinamis atau tidak. Kamera juga memiliki bendera allowDynamicResolution, yang dapat Anda gunakan untuk mengatur resolusi dinamis sehingga tidak perlu menimpa target render jika Anda hanya ingin menerapkan resolusi dinamis ke SceneAdegan berisi lingkungan dan menu permainan Anda. Pikirkan setiap file Adegan unik sebagai tingkat yang unik. Di setiap Adegan, Anda menempatkan lingkungan, hambatan, dan dekorasi, pada dasarnya merancang dan membangun permainan Anda dalam potongan-potongan. More info
Lihat di Glossary yang kurang kompleks.

MRT buffers

Ketika Anda mengaktifkan Allow Dynamic Resolution pada Kamera, skala Unity semua target Kamera itu.

Mengontrol scaling

Anda dapat mengontrol skala melalui ScalableBufferManager. ScalableBufferManager memberi Anda kontrol lebar dinamis dan skala tinggi untuk semua target render Anda telah ditandai untuk sistem resolusi dinamis untuk skala.

Sebagai contoh, asumsikan aplikasi Anda berjalan pada tingkat bingkai yang diinginkan, tetapi dalam beberapa keadaan kinerja GPU menurun, karena kombinasi partikel yang meningkat, efek pasca dan kompleksitas layar. Unity FrameTimingManager memungkinkan Anda untuk mendeteksi ketika kinerja CPU atau GPU mulai berkurang. Jadi Anda dapat menggunakan FrameTimingManager untuk menghitung lebar baru yang diinginkan dan skala tinggi untuk menjaga tingkat bingkai dalam kisaran yang diinginkan Anda, dan membawa skala ke nilai itu untuk menjaga kinerja stabil (baik secara langsung atau secara bertahap atas sejumlah bingkai). Ketika kompleksitas layar berkurang dan GPU berkinerja konsisten, Anda kemudian dapat meningkatkan skala lebar dan tinggi kembali ke nilai yang telah Anda menghitung GPU dapat menangani.

Example

Script contoh ini menunjukkan penggunaan dasar API. Tambahkan ke kamera di tempat kejadian Anda, dan periksa Allow Dynamic Resolution di pengaturan kamera. Anda juga perlu membuka pengaturan Player (menu: Edit > Project Settings, kemudian pilih kategori Player) dan periksa kotak cemen. Untuk informasi lebih lanjut tentang fungsionalitas di balik properti Enable Frame Timing Stats, lihat Enable Frame Timing Stats.FrameTimingManager.

Mengklik mouse, atau mengetuk layar dengan satu jari, menurunkan resolusi tinggi dan lebar dengan jumlah dalam variabel scaleWidthIncrement dan scaleHeightIncrement masing-masing. Ketuk dengan dua jari meningkatkan resolusi dengan kenaikan yang sama.

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class DynamicResolutionTest : MonoBehaviour
{
    public Text screenText;

    FrameTiming[] frameTimings = new FrameTiming[3];

    public float maxResolutionWidthScale = 1.0f;
    public float maxResolutionHeightScale = 1.0f;
    public float minResolutionWidthScale = 0.5f;
    public float minResolutionHeightScale = 0.5f;
    public float scaleWidthIncrement = 0.1f;
    public float scaleHeightIncrement = 0.1f;

    float m_widthScale = 1.0f;
    float m_heightScale = 1.0f;

    // Variables for dynamic resolution algorithm that persist across frames
    uint m_frameCount = 0;

    const uint kNumFrameTimings = 2;

    double m_gpuFrameTime;
    double m_cpuFrameTime;

    // Use this for initialization
    void Start()
    {
        int rezWidth = (int)Mathf.Ceil(ScalableBufferManager.widthScaleFactor * Screen.currentResolution.width);
        int rezHeight = (int)Mathf.Ceil(ScalableBufferManager.heightScaleFactor * Screen.currentResolution.height);
        screenText.text = string.Format("Scale: {0:F3}x{1:F3}\nResolution: {2}x{3}\n",
            m_widthScale,
            m_heightScale,
            rezWidth,
            rezHeight);
    }

    // Update is called once per frame
    void Update()
    {
        float oldWidthScale = m_widthScale;
        float oldHeightScale = m_heightScale;

        // One finger lowers the resolution
        if (Input.GetButtonDown("Fire1"))
        {
            m_heightScale = Mathf.Max(minResolutionHeightScale, m_heightScale - scaleHeightIncrement);
            m_widthScale = Mathf.Max(minResolutionWidthScale, m_widthScale - scaleWidthIncrement);
        }

        // Two fingers raises the resolution
        if (Input.GetButtonDown("Fire2"))
        {
            m_heightScale = Mathf.Min(maxResolutionHeightScale, m_heightScale + scaleHeightIncrement);
            m_widthScale = Mathf.Min(maxResolutionWidthScale, m_widthScale + scaleWidthIncrement);
        }

        if (m_widthScale != oldWidthScale || m_heightScale != oldHeightScale)
        {
            ScalableBufferManager.ResizeBuffers(m_widthScale, m_heightScale);
        }
        DetermineResolution();
        int rezWidth = (int)Mathf.Ceil(ScalableBufferManager.widthScaleFactor * Screen.currentResolution.width);
        int rezHeight = (int)Mathf.Ceil(ScalableBufferManager.heightScaleFactor * Screen.currentResolution.height);
        screenText.text = string.Format("Scale: {0:F3}x{1:F3}\nResolution: {2}x{3}\nScaleFactor: {4:F3}x{5:F3}\nGPU: {6:F3} CPU: {7:F3}",
            m_widthScale,
            m_heightScale,
            rezWidth,
            rezHeight,
            ScalableBufferManager.widthScaleFactor,
            ScalableBufferManager.heightScaleFactor,
            m_gpuFrameTime,
            m_cpuFrameTime);
    }

    // Estimate the next frame time and update the resolution scale if necessary.
    private void DetermineResolution()
    {
        ++m_frameCount;
        if (m_frameCount <= kNumFrameTimings)
        {
            return;
        }
        FrameTimingManager.CaptureFrameTimings();
        FrameTimingManager.GetLatestTimings(kNumFrameTimings, frameTimings);
        if (frameTimings.Length < kNumFrameTimings)
        {
            Debug.LogFormat("Skipping frame {0}, didn't get enough frame timings.",
                m_frameCount);

            return;
        }

        m_gpuFrameTime = (double)frameTimings[0].gpuFrameTime;
        m_cpuFrameTime = (double)frameTimings[0].cpuFrameTime;
    }
}

Manual Unity