Unity Oyunlarında Tam Ekran Modunu Yönetme: Screen.fullScreen

Giriş: Neden Tam Ekran Kontrolü Önemli?

Oyun geliştirirken, oyunculara akıcı ve kişiselleştirilebilir bir deneyim sunmak hayati önem taşır. Bu deneyimin önemli bir parçası da oyunun ekran modunu (tam ekran, pencereli vb.) ve çözünürlüğünü kontrol edebilmektir. Unity motoru, bu ihtiyacı karşılamak için bize güçlü araçlar sunar. Özellikle Screen.fullScreen özelliği, oyununuzun tam ekran durumunu kolayca yönetmenizi sağlar. Bu makalede, Unity tam ekran kontrolü mekanizmalarını derinlemesine inceleyecek, temel kullanımlarından ileri seviye ipuçlarına kadar birçok konuya değineceğiz.

Oyuncuların farklı donanım ve tercihlere sahip olduğunu düşünürsek, oyunun varsayılan olarak belirli bir ekran modunda başlaması veya oyuncunun istediği zaman bu modu değiştirebilmesi, oyunun erişilebilirliğini ve kullanıcı memnuniyetini doğrudan etkiler. Yanlış yapılandırılmış bir tam ekran deneyimi, oyuncuların oyunu kapatmasına bile neden olabilir. Bu nedenle, bu konuya hakim olmak her Unity geliştiricisi için önemlidir.

Screen.fullScreen Nedir? Temelleri

Screen.fullScreen, Unity'nin Screen sınıfına ait bir bool (doğru/yanlış) özelliğidir. Adından da anlaşılacağı gibi, oyunun şu anda tam ekran modunda olup olmadığını gösterir veya bu modu ayarlar. Eğer true ise oyun tam ekrandadır, false ise pencereli moddadır.

Bu özelliği kullanmak oldukça basittir. Oyunun tam ekran durumunu okumak için:

bool suAnTamEkranMi = Screen.fullScreen;

Oyunun tam ekran durumunu değiştirmek için:

// Oyunu tam ekrana al
Screen.fullScreen = true;

// Oyunu pencereli moda al
Screen.fullScreen = false;

Genellikle, bir tuşa basıldığında veya bir UI butonu tıklandığında tam ekran modunu değiştirmek isteriz. İşte basit bir örnek:

using UnityEngine;

public class TamEkranKontrolcu : MonoBehaviour
{
    void Update()
    {
        // 'F' tuşuna basıldığında tam ekran modunu değiştir
        if (Input.GetKeyDown(KeyCode.F))
        {
            Screen.fullScreen = !Screen.fullScreen;
            Debug.Log(\"Tam Ekran Durumu: \" + Screen.fullScreen);
        }
    }
}

Bu kod bloğu, 'F' tuşuna her basıldığında oyunun tam ekran durumunu tersine çevirir. Oldukça basit, değil mi? Ancak gerçek dünya senaryolarında, çözünürlük gibi başka faktörleri de göz önünde bulundurmamız gerekir.

Screen.SetResolution ile Çözünürlük ve Tam Ekran

Screen.fullScreen özelliği sadece tam ekran durumunu kontrol ederken, oyunun hangi çözünürlükte çalışacağını belirlemek için Screen.SetResolution metodunu kullanırız. Bu metot, oyunun genişliğini, yüksekliğini ve tam ekran durumunu birlikte ayarlamamıza olanak tanır. Ayrıca, daha modern yaklaşımlar için FullScreenMode enum'unu da kabul eder.

Screen.SetResolution metodunun yaygın kullanımları şunlardır:

// Belirli bir çözünürlükte tam ekrana geçiş
Screen.SetResolution(1920, 1080, true);

// Belirli bir çözünürlükte pencereli moda geçiş
Screen.SetResolution(1280, 720, false);

Bu metodun üçüncü parametresi doğrudan bir bool değeri (true/false) olabileceği gibi, daha esnek kontrol için bir FullScreenMode enum değeri de olabilir. Bu, Unity tam ekran kontrolü konusunda bize daha fazla güç verir.

FullScreenMode Enum ile Daha Detaylı Kontrol

Unity 2017.1'den itibaren Screen.fullScreenMode özelliği ve FullScreenMode enum'u ile tam ekran deneyimi üzerinde daha fazla kontrol sahibi olabiliyoruz. Bu enum, dört farklı tam ekran modunu tanımlar:

• FullScreenMode.ExclusiveFullScreen: Geleneksel tam ekran modudur. Oyun, monitörün kontrolünü tamamen ele geçirir. Genellikle en iyi performans ve en düşük gecikmeyi sunar.
• FullScreenMode.FullScreenWindow: Kenarlıksız tam ekran veya penceresiz tam ekran olarak da bilinir. Oyun, ekranı kaplayan bir pencere olarak çalışır. Pencere ile masaüstü arasında geçiş yapmak daha hızlıdır ancak performans avantajı ExclusiveFullScreen kadar belirgin olmayabilir.
• FullScreenMode.Windowed: Oyun, ayarlanmış çözünürlükte normal bir pencere içinde çalışır.
• FullScreenMode.MaximizeWindow: Oyun, maksimum boyuta getirilmiş (pencereyi kaplayan) bir pencere içinde çalışır. Genellikle FullScreenWindow ile benzer bir görsel sonuç verir ancak farklı işletim sistemi API'leri kullanabilir.

Bu modları Screen.SetResolution ile birlikte kullanabiliriz:

using UnityEngine;

public class GelismisEkranKontrolcu : MonoBehaviour
{
    public int genislik = 1920;
    public int yukseklik = 1080;
    public FullScreenMode ekranModu = FullScreenMode.ExclusiveFullScreen;

    void Start()
    {
        // Oyun başlangıcında varsayılan ayarları uygula
        Screen.SetResolution(genislik, yukseklik, ekranModu);
        Debug.Log($\"Ekran {genislik}x{yukseklik} çözünürlüğünde {ekranModu} modunda başlatıldı.\");
    }

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Alpha1)) // '1' tuşu
        {
            ekranModu = FullScreenMode.ExclusiveFullScreen;
            Screen.SetResolution(genislik, yukseklik, ekranModu);
            Debug.Log(\"Exclusive FullScreen moduna geçildi.\");
        }
        else if (Input.GetKeyDown(KeyCode.Alpha2)) // '2' tuşu
        {
            ekranModu = FullScreenMode.FullScreenWindow;
            Screen.SetResolution(genislik, yukseklik, ekranModu);
            Debug.Log(\"Borderless FullScreen moduna geçildi.\");
        }
        else if (Input.GetKeyDown(KeyCode.Alpha3)) // '3' tuşu
        {
            ekranModu = FullScreenMode.Windowed;
            Screen.SetResolution(genislik, yukseklik, ekranModu);
            Debug.Log(\"Pencereli moduna geçildi.\");
        }
    }
}

Pratik İpuçları

İpucu 1: Oyun Başlangıcında Varsayılan Ayarlar

Oyununuzun her zaman belirli bir çözünürlük ve ekran modunda başlamasını sağlamak önemlidir. Bunu genellikle Start metodunda veya oyunun ilk yüklendiği sahnede yapabiliriz. Oyuncunun daha önce kaydettiği tercihleri yoksa, varsayılan bir ayar uygulamak iyi bir yaklaşımdır. Bu, Unity tam ekran kontrolü için temel bir başlangıç noktasıdır.

void Start()
{
    // Varsayılan olarak 1920x1080 FullScreenWindow modunda başlat
    if (!PlayerPrefs.HasKey(\"CozunurlukGenislik\")) // Daha önce kaydedilmiş ayar yoksa
    {
        Screen.SetResolution(1920, 1080, FullScreenMode.FullScreenWindow);
    }
    else // Kaydedilmiş ayarlar varsa onları yükle
    {
        int kaydedilenGenislik = PlayerPrefs.GetInt(\"CozunurlukGenislik\");
        int kaydedilenYukseklik = PlayerPrefs.GetInt(\"CozunurlukYukseklik\");
        FullScreenMode kaydedilenMod = (FullScreenMode)PlayerPrefs.GetInt(\"EkranModu\");
        Screen.SetResolution(kaydedilenGenislik, kaydedilenYukseklik, kaydedilenMod);
    }
}

İpucu 2: Kullanıcı Arayüzü (UI) ile Tam Ekran Geçişi

Oyuncuların oyun içi ayarlar menüsünden ekran modunu değiştirebilmesi yaygın bir beklentidir. Bir UI Toggle veya Dropdown kullanarak bu işlevi sunabilirsiniz. Toggle için basit bir örnek:

using UnityEngine;
using UnityEngine.UI; // UI elemanları için
using TMPro; // TextMeshPro kullanıyorsanız

public class UI_EkranAyarlari : MonoBehaviour
{
    public Toggle tamEkranToggle;
    public TMP_Dropdown cozunurlukDropdown; // Opsiyonel: Çözünürlük seçimi için

    void Start()
    {
        // Toggle'ın mevcut tam ekran durumunu yansıtmasını sağla
        tamEkranToggle.isOn = Screen.fullScreen;
        // Toggle'ın durum değiştiğinde çağrılacak metodu ekle
        tamEkranToggle.onValueChanged.AddListener(OnTamEkranToggleDegisti);

        // Çözünürlük dropdown'ını doldurma (örnek)
        // Gerçek projede Screen.resolutions kullanılarak dinamik doldurulmalı
        if (cozunurlukDropdown != null)
        {
            cozunurlukDropdown.ClearOptions();
            foreach (Resolution res in Screen.resolutions)
            {
                cozunurlukDropdown.options.Add(new TMP_Dropdown.OptionData(res.width + \"x\" + res.height));
                if (res.width == Screen.currentResolution.width && res.height == Screen.currentResolution.height)
                {
                    cozunurlukDropdown.value = cozunurlukDropdown.options.Count - 1;
                }
            }
            cozunurlukDropdown.RefreshShownValue();
            cozunurlukDropdown.onValueChanged.AddListener(OnCozunurlukDegisti);
        }
    }

    public void OnTamEkranToggleDegisti(bool isFullScreen)
    {
        // Mevcut çözünürlük ve seçilen tam ekran modu ile ayarla
        Screen.SetResolution(Screen.currentResolution.width, Screen.currentResolution.height, isFullScreen ? FullScreenMode.FullScreenWindow : FullScreenMode.Windowed);
        Debug.Log(\"Tam Ekran Toggle Durumu: \" + isFullScreen);

        // Ayarları kaydet
        PlayerPrefs.SetInt(\"EkranModu\", isFullScreen ? (int)FullScreenMode.FullScreenWindow : (int)FullScreenMode.Windowed);
        PlayerPrefs.Save();
    }

    public void OnCozunurlukDegisti(int index)
    {
        // Dropdown'dan seçilen çözünürlüğü ve mevcut ekran modunu uygula
        Resolution secilenCozunurluk = Screen.resolutions[index];
        Screen.SetResolution(secilenCozunurluk.width, secilenCozunurluk.height, Screen.fullScreenMode);
        Debug.Log(\"Çözünürlük değişti: \" + secilenCozunurluk.width + \"x\" + secilenCozunurluk.height);

        // Ayarları kaydet
        PlayerPrefs.SetInt(\"CozunurlukGenislik\", secilenCozunurluk.width);
        PlayerPrefs.SetInt(\"CozunurlukYukseklik\", secilenCozunurluk.height);
        PlayerPrefs.Save();
    }
}

İpucu 3: Kullanıcının Tercihlerini Kaydetme ve Yükleme

Oyuncuların her oyun açılışında ayarları yeniden yapmasını istemeyiz. PlayerPrefs kullanarak bu tercihleri kaydedebilir ve oyun her başladığında yükleyebiliriz. Bu, Unity tam ekran kontrolü deneyimini çok daha kullanıcı dostu hale getirir.

// Ayarları kaydetme (örnek)
void KaydetAyarlar()
{
    PlayerPrefs.SetInt(\"CozunurlukGenislik\", Screen.currentResolution.width);
    PlayerPrefs.SetInt(\"CozunurlukYukseklik\", Screen.currentResolution.height);
    PlayerPrefs.SetInt(\"EkranModu\", (int)Screen.fullScreenMode); // Enum'u int olarak kaydet
    PlayerPrefs.Save(); // Değişiklikleri diske yaz
}

// Ayarları yükleme (örnek)
void YukleAyarlar()
{
    if (PlayerPrefs.HasKey(\"CozunurlukGenislik\"))
    {
        int genislik = PlayerPrefs.GetInt(\"CozunurlukGenislik\");
        int yukseklik = PlayerPrefs.GetInt(\"CozunurlukYukseklik\");
        FullScreenMode mod = (FullScreenMode)PlayerPrefs.GetInt(\"EkranModu\");
        Screen.SetResolution(genislik, yukseklik, mod);
    }
    else
    {
        // İlk çalıştırma veya kayıt yoksa varsayılanları ayarla
        Screen.SetResolution(1920, 1080, FullScreenMode.FullScreenWindow);
    }
}

İpucu 4: Dinamik Çözünürlük Listesi Oluşturma

Oyunculara monitörlerinin desteklediği tüm çözünürlükleri sunmak için Screen.resolutions özelliğini kullanabilirsiniz. Bu, bir Dropdown menüsünü doldurmak için idealdir.

using UnityEngine;
using System.Collections.Generic; // List için
using TMPro; // TextMeshPro kullanıyorsanız

public class CozunurlukListesiOlusturucu : MonoBehaviour
{
    public TMP_Dropdown cozunurlukDropdown;
    private List<Resolution> mevcutCozunurlukler = new List<Resolution>();

    void Start()
    {
        mevcutCozunurlukler.Clear();
        cozunurlukDropdown.ClearOptions();

        int currentResolutionIndex = 0;
        for (int i = 0; i < Screen.resolutions.Length; i++)
        {
            Resolution res = Screen.resolutions[i];
            // Yalnızca benzersiz çözünürlükleri ekle (bazı monitörler aynı çözünürlüğü farklı yenileme hızlarıyla listeler)
            if (!mevcutCozunurlukler.Exists(r => r.width == res.width && r.height == res.height))
            {
                mevcutCozunurlukler.Add(res);
                cozunurlukDropdown.options.Add(new TMP_Dropdown.OptionData(res.width + \"x\" + res.height));

                if (res.width == Screen.currentResolution.width && res.height == Screen.currentResolution.height)
                {
                    currentResolutionIndex = mevcutCozunurlukler.Count - 1; // Eklendikten sonraki indeksi ayarla
                }
            }
        }

        cozunurlukDropdown.value = currentResolutionIndex;
        cozunurlukDropdown.RefreshShownValue();
        cozunurlukDropdown.onValueChanged.AddListener(OnCozunurlukSecildi);
    }

    void OnCozunurlukSecildi(int index)
    {
        Resolution secilenCozunurluk = mevcutCozunurlukler[index];
        Screen.SetResolution(secilenCozunurluk.width, secilenCozunurluk.height, Screen.fullScreenMode);
        Debug.Log(\"Yeni çözünürlük: \" + secilenCozunurluk.width + \"x\" + secilenCozunurluk.height);
        // Ayarları kaydetmeyi unutmayın
        PlayerPrefs.SetInt(\"CozunurlukGenislik\", secilenCozunurluk.width);
        PlayerPrefs.SetInt(\"CozunurlukYukseklik\", secilenCozunurluk.height);
        PlayerPrefs.Save();
    }
}

Yaygın Hatalar ve Çözümleri

1. Sadece Screen.fullScreen kullanmak ve çözünürlüğü göz ardı etmek:
Oyunu tam ekrana alırken veya pencereli moda geçirirken, genellikle çözünürlüğün de doğru ayarlandığından emin olmak istersiniz. Sadece Screen.fullScreen = true; demek, mevcut çözünürlüğü tam ekrana yayabilir, bu da her zaman istenen sonuç olmayabilir. Çözüm: Her zaman Screen.SetResolution(genislik, yukseklik, tamEkranModu); metodunu kullanın.

2. FullScreenMode yerine sadece bool kullanmak:
Daha eski Unity versiyonlarında sadece bool parametresi vardı. Ancak günümüzde FullScreenMode enum'u ile daha fazla kontrol imkanınız var. Çözüm: Eğer daha modern ve esnek bir tam ekran deneyimi sunmak istiyorsanız, FullScreenMode enum'unu kullanın.

3. WebGL ve Mobil Platformlarda farklı davranışlar:
Web tarayıcıları ve mobil cihazlar, tam ekran yönetimi konusunda masaüstü uygulamalarından farklı kısıtlamalara sahip olabilir. Örneğin, WebGL'de tam ekran geçişleri genellikle bir kullanıcı etkileşimi (tıklama gibi) gerektirir ve tarayıcının kendi tam ekran API'lerini kullanır. Çözüm: Hedef platformların dokümantasyonunu dikkatlice inceleyin ve platforma özgü koşulları göz önünde bulundurun.

4. Update içinde sürekli ekran ayarı yapmak:
Screen.SetResolution gibi metotlar performans açısından maliyetli olabilir. Her framede bu metotları çağırmak gereksiz CPU yüküne neden olur. Çözüm: Ekran ayarlarını yalnızca kullanıcı bir değişiklik yaptığında veya oyun başladığında uygulayın.

Performans ve Optimizasyon Notları

Screen.SetResolution veya Screen.fullScreen gibi ekran ayarlarını değiştiren işlemler, Unity'nin render pipeline'ını etkileyebilir ve kısa süreli takılmalara neden olabilir. Bu nedenle:

• Bu işlemleri sık sık, özellikle de her karede (Update metodunda) çağırmaktan kaçının.
• Ekran ayarlarını değiştirirken, mümkünse bu işlemi oyunun akışını kesintiye uğratmayacak, örneğin bir menü ekranında veya sahne geçişi sırasında yapın.
• Oyuncuların sistem kaynaklarına ve monitör özelliklerine uygun çözünürlük seçenekleri sunun. Çok yüksek çözünürlükler eski donanımlarda performansı düşürebilir.

Sonuç

Unity'de Screen.fullScreen ve Screen.SetResolution ile Unity tam ekran kontrolü, oyununuzun kullanıcı deneyimi için kritik bir özelliktir. Bu makalede, bu özelliklerin temellerini, FullScreenMode enum'u ile daha detaylı kontrolü, pratik ipuçlarını, yaygın hataları ve performans notlarını ele aldık. Oyuncularınıza esnek ve sorunsuz bir ekran deneyimi sunarak oyununuzun kalitesini artırabilirsiniz. Unutmayın, iyi bir kullanıcı deneyimi, başarılı bir oyunun temel taşlarından biridir.