UE’de Minyatür DoF Etkisi: HLSL ile Özel Alan Derinliği Nasıl Oluşturulur?

Oyun ve görselleştirme dünyasında, basit bir kamera efektinin bile projenizin atmosferini kökten değiştirebileceğini biliyor muydunuz? Bu makale, Unreal Engine’de HLSL kullanarak kendi minyatür tarzı Alan Derinliği (DoF) efektinizi adım adım nasıl oluşturacağınızı açıklıyor.

Dijital oyunlar ve interaktif deneyimler, görsel çekicilikleriyle kullanıcıyı içine çekme gücüne sahiptir. Ancak, çoğu zaman standart grafik ayarları veya hazır efektler, projenin arzu edilen sanatsal vizyonunu tam olarak yansıtmayabilir. Özellikle, bir sahneye “minyatür” veya “oyuncak” benzeri bir görünüm kazandırmak istediğimizde, standart Alan Derinliği (Depth of Field – DoF) efektleri yetersiz kalabilir. Peki, bu durumda ne yapmalıyız?

Minyatür tarzı DoF, gerçek dünyadaki tilt-shift fotoğrafçılık tekniğinden ilham alır. Bu teknik, belirli bir odak düzlemi dışındaki her şeyi bulanıklaştırarak, izleyicide sahnenin küçük bir maket olduğu izlenimini yaratır. Odaklanılan alanın keskinliği korunurken, yakın ve uzak mesafelerdeki objelerin bulanıklaşması, sanki minyatür bir dünyayı yukarıdan izliyormuşuz gibi bir algı oluşturur. Bu, sadece estetik bir tercih olmanın ötesinde, oyunun veya görselleştirmenin hikaye anlatımına da önemli katkılar sağlayabilir.

Örneğin, bir strateji oyununda oyuncunun belirli bir bölgeye odaklanmasını sağlamak veya bir bulmaca oyununda önemli ipuçlarını vurgulamak için minyatür DoF kullanılabilir. Aynı zamanda, sanatsal bir stil yaratmak isteyen bağımsız geliştiriciler için de güçlü bir araçtır. Unreal Engine gibi güçlü bir platformda, bu tür bir efekti doğrudan HLSL (High-Level Shading Language) kullanarak özel olarak geliştirmek, bize hem esneklik hem de performans üzerinde tam kontrol sağlar. Bu, hazır çözümlerin sunamadığı ince ayarlar ve sanatsal yönlendirmeler için vazgeçilmezdir. Dolayısıyla, sadece görsel bir şölen sunmakla kalmayıp, aynı zamanda oyunun genel deneyimini zenginleştiren bir araçtır. Bu makale boyunca, bu büyüleyici efekti kendi projelerinizde nasıl uygulayacağınızı adım adım keşfedeceğiz.

Gerçek dünya senaryolarında, mimari görselleştirmelerde binaların bir maket gibi görünmesini sağlamak ya da ürün tanıtımlarında ana objeyi vurgulayıp geri kalanı minyatürleştirmek için de bu teknik yaygın olarak kullanılır. Bu, izleyicinin dikkatini doğrudan belirli bir noktaya çekmenin ve algılanan ölçeği manipüle etmenin etkili bir yoludur. Hazır çözümlerin sunduğu sınırlamaların aksine, HLSL ile sıfırdan bir DoF efekti oluşturmak, geliştiricilere piksel düzeyinde kontrol imkanı sunar ve böylece görsel hedeflere çok daha hassas bir şekilde ulaşılmasını sağlar.

Alan Derinliği (DoF) Nedir ve Nasıl Çalışır? Temel Bilgiler

Bir kamera veya gözümüz, aslında belirli bir mesafedeki objeleri net bir şekilde görürken, bu odak düzleminin önündeki veya arkasındaki objeleri giderek daha bulanık gösterir. İşte bu netlik aralığına Alan Derinliği (Depth of Field – DoF) denir. Peki, bu olgu dijital grafiklerde nasıl taklit edilir ve neden bu kadar önemlidir?

DoF, temel olarak üç ana faktöre bağlıdır: odak uzaklığı (focal length), diyafram açıklığı (aperture/f-stop) ve objenin kameraya olan uzaklığı. Geniş bir diyafram (düşük f-stop değeri) veya uzun bir odak uzaklığı, daha sığ bir alan derinliği (yani daha bulanık bir arka plan) yaratırken, dar bir diyafram (yüksek f-stop değeri) veya kısa odak uzaklığı, daha geniş bir netlik alanı sunar. Gerçek dünya optiğinde, bir noktadan gelen ışık, sensöre veya filme odaklandığında net bir “nokta” olarak görünür. Odak dışı kalan noktalardan gelen ışık ise bir “bulanıklık dairesi” (Circle of Confusion – CoC) olarak yayılır. CoC’nin boyutu ne kadar büyük olursa, bulanıklık da o kadar belirgin olur.

Gerçek zamanlı grafiklerde DoF oluşturmak, genellikle post-processing efektleri aracılığıyla yapılır. Ekran görüntüsü ve derinlik bilgisi alınır ve her piksel için bir bulanıklık değeri hesaplanır. Unreal Engine gibi oyun motorları, genellikle güçlü yerleşik DoF çözümleri sunar. Ancak, bu çözümler genellikle performans veya sanatsal kontrol açısından belirli sınırlamalara sahiptir. Örneğin, yerleşik DoF efektleri bazen belirli bulanıklık şekillerini (bokeh) veya minyatür tarzı odaklama modellerini tam olarak desteklemeyebilir, ya da performans maliyetleri yüksek olabilir.

İşte bu noktada HLSL (High-Level Shading Language) devreye girer. HLSL, Microsoft tarafından DirectX API’si için geliştirilmiş bir shader dilidir ve GPU üzerinde doğrudan çalıştırılan programlar yazmanıza olanak tanır. Bir shader, genellikle bir pikselin rengini veya bir vertex’in konumunu belirlemek gibi görevleri yerine getirir. Özel bir DoF efekti oluşturmak için, ekranın her pikseli için derinlik bilgisini okuyacak, CoC değerini hesaplayacak ve bu değere göre pikselleri bulanıklaştıracak bir piksel shader’ı yazmamız gerekir. Bu sayede, standart DoF çözümlerinin ötesine geçerek, tamamen özelleştirilebilir, performans odaklı ve sanatsal vizyonunuza uygun bir Alan Derinliği efekti yaratabiliriz. Bu yaklaşım, sadece görsel kaliteyi artırmakla kalmaz, aynı zamanda projenizin benzersizliğini de vurgular. HLSL ile çalışmak, grafik boru hattı üzerinde derinlemesine bir anlayış geliştirmenize de yardımcı olacaktır.

Bu temel prensipleri anlamak, özel bir DoF shader’ı geliştirirken size rehberlik edecektir. Her bir pikselin derinlik değeri, odak noktasına olan uzaklığına göre bir CoC değeriyle eşleştirilecek ve bu CoC değeri, nihai bulanıklık miktarını belirleyecektir. Bu karmaşık sürecin her aşamasını HLSL kodlarıyla kontrol etmek, geliştiricilere rakipsiz bir esneklik sunar.

UE ve HLSL Ortamında Özel DoF Shader’ı Geliştirmeye Başlarken

Unreal Engine’de özel bir post-processing efekti oluşturmanın en yaygın yolu, Post-Process Material kullanmaktır. Ancak, daha fazla kontrol ve doğrudan GPU erişimi için HLSL tabanlı Custom Node’ları veya Global Shader’ları tercih edebiliriz. Minyatür tarzı bir DoF efekti için, ekran derinliğini okuyup özel bulanıklık hesaplamaları yapacağımız bir Custom Node en iyi başlangıç noktasıdır.

İlk adım olarak, Unreal Engine projenizde yeni bir Materyal (Material) oluşturun ve bu materyalin “Material Domain” özelliğini “Post Process” olarak ayarlayın. Bu materyal, sahnede renderlendikten sonra tüm görüntüye uygulanacaktır. Materyal editöründe, ana nodunuza (Result) bir “Custom” düğümü ekleyin. Bu düğüm, HLSL kodumuzu yazacağımız yerdir.

Custom düğümünün “Code” alanına HLSL kodumuzu yazacağız. Ayrıca, shader’a dışarıdan veri aktarabilmek için “Inputs” bölümünde parametreler tanımlamamız gerekecek. Başlangıç olarak, ekran rengini ve derinliğini almalıyız. Unreal Engine’de, sahne derinliğine “SceneDepth” düğümü aracılığıyla erişilebilir. Ekran rengine ise “SceneTexture” düğümü ve “PostProcessInput0” veya “SceneColor” ile erişebiliriz. Bu girişleri Custom düğümüne bağlamamız gerekecektir.

// Unreal Engine Custom Node içinde temel HLSL yapısı

// Giriş parametreleri
// Default: SceneTexture:PostProcessInput0
float4 SceneColorInput; 
// Default: SceneDepth
float SceneDepthInput; 
// Odak mesafesi (örneğin, 1000.0 birim)
float FocalDistance; 
// Odak genişliği (netlik alanı, örneğin, 100.0 birim)
float FocalRange; 
// Maksimum bulanıklık miktarı
float MaxBlurAmount; 

// Fragment pozisyonunu alın (0-1 aralığında UV koordinatları)
float2 UV = GetScreenPosition().xy / GetScreenPosition().w;

// Pikselin gerçek dünya derinliğini alın
float PixelDepth = CalcSceneDepth(UV); // Veya doğrudan SceneDepthInput kullanın

// Odak düzlemine olan mesafeyi hesaplayın
float DistanceToFocus = abs(PixelDepth - FocalDistance);

// Bulanıklık miktarını belirlemek için CoC benzeri bir değer hesaplayın
// FocalRange içinde olanlar net, dışarıdakiler bulanıklaşır.
float CoC = saturate((DistanceToFocus - FocalRange / 2.0f) / (FocalRange / 2.0f));
CoC *= MaxBlurAmount; // Maksimum bulanıklık miktarını uygulayın

// Şimdilik sadece CoC'yi renk olarak görselleştirelim
// Kırmızı kanal bulanıklık miktarını göstersin
// return float4(CoC, CoC, CoC, 1.0);

// Henüz bulanıklık uygulamazsak, sadece orijinal rengi döndür
return SceneColorInput;

Yukarıdaki HLSL kodu, Custom düğümü içinde kullanılabilir. Bu kodda, FocalDistance ve FocalRange gibi değişkenleri materyal parametreleri olarak tanımlayarak dışarıdan kontrol edebiliriz. CalcSceneDepth(UV) fonksiyonu veya doğrudan SceneDepthInput ile pikselin derinliğini alırız. Daha sonra, bu derinliğin FocalDistance'a ne kadar yakın olduğuna bakarak bir CoC (Circle of Confusion) değeri hesaplıyoruz. saturate fonksiyonu, değeri 0 ile 1 arasına sıkıştırır. Başlangıçta, sadece CoC değerini görselleştirerek hangi bölgelerin bulanıklaşacağını görebiliriz. Bu, hata ayıklama için harika bir yoldur. Ayrıca, bu aşamada materyal çıktısını SceneColorInput olarak bırakarak, efekti uygulamadan önce tüm ayarların doğru çalıştığından emin olabiliriz.

Materyal içindeki bu Custom Node'u ayarladıktan sonra, Post-Process Volume'unuza bu materyali eklemeniz gerekir. Bunun için Post-Process Volume detaylarında "Rendering Features" altında "Post Process Materials" bölümünü bulun, yeni bir Array öğesi ekleyin ve "Asset Reference" olarak oluşturduğunuz materyali seçin. İşte bu noktada, temel bir minyatür DoF efekti için ilk adımları atmış olursunuz. Materyal parametrelerini değiştirerek odak noktasını ve bulanıklık şiddetini kolayca ayarlayabilirsiniz. Bu adımlar, efektin temelini oluşturur ve ileride daha karmaşık bulanıklık algoritmaları ve optimizasyonlar için sağlam bir zemin hazırlar.

Bu bölüm, Unreal Engine'in materyal editörü ve HLSL arasındaki köprüyü kurarak özel bir post-processing efekti geliştirmeye başlamanın ilk pratik adımlarını sunar. Bu temel kurulum, daha karmaşık algoritmaları ve optimizasyonları entegre etmek için güçlü bir başlangıç noktasıdır.

HLSL ile Alan Derinliği Hesaplamalarının Matematiksel Temelleri

Minyatür DoF efektinin kalbinde, her bir pikselin ne kadar bulanık olması gerektiğini belirleyen matematiksel hesaplamalar yatar. Bu hesaplamalar, gerçek dünya kameralarının çalışma prensiplerini taklit eder ve Alan Derinliği'nin temelini oluşturan Bulanıklık Dairesi (Circle of Confusion - CoC) kavramına dayanır. CoC'nin boyutu, bir pikselin odak düzleminden ne kadar uzakta olduğuna bağlı olarak değişir.

Bir pikselin CoC değerini hesaplamak için, önce kamera parametrelerini anlamamız gerekir. Genellikle şunlara ihtiyaç duyarız:

• Focal Distance (Odak Mesafesi): Kameranın net olduğu mesafe.
• Focal Length (Odak Uzaklığı): Kameranın lensinin odak uzaklığı. (Genellikle UE'de PostProcess materyalleri için bu değer dahili olarak kullanılır veya bir parametre olarak sağlanır.)
• Aperture/f-stop (Diyafram Açıklığı): Lensin ışık geçirme kapasitesi; küçük değerler daha sığ DoF anlamına gelir.
• Sensor Size: Kameranın sensör boyutu.
• Pixel Depth (Piksel Derinliği): Renderlanan sahnedeki her pikselin kameradan olan uzaklığı.

Basitleştirilmiş bir CoC hesaplaması genellikle şu şekilde ifade edilebilir:

// CoC = abs(PixelDepth - FocalDistance) * (FocalLength * FocalLength) / (Aperture * (FocalDistance - FocalLength) * PixelDepth);

Ancak, gerçek zamanlı shader'larda genellikle bu formül daha da basitleştirilir veya sanatsal kontrole odaklanılır. Bizim minyatür tarzı DoF'umuz için, odak düzlemine olan uzaklığa dayalı daha sezgisel bir yaklaşım kullanabiliriz. Amaç, belirli bir "netlik aralığı" dışındaki pikselleri bulanıklaştırmaktır.

Önceki bölümde başlattığımız HLSL kodunu geliştirerek, CoC'yi daha gerçekçi bir şekilde hesaplayabiliriz:

// Unreal Engine Custom Node içinde HLSL CoC hesaplaması

// Giriş parametreleri
float4 SceneColorInput; 
float SceneDepthInput; 
float FocalDistance;     // Kamera odak mesafesi
float FocalLength;       // Kamera odak uzaklığı (örneğin, 50mm için 0.05)
float Aperture;          // Diyafram (f-stop değeri, örneğin, f/2.8 için 2.8)
float MaxCoCRadius;      // Maksimum CoC yarıçapı (piksel cinsinden)

float2 UV = GetScreenPosition().xy / GetScreenPosition().w;
float PixelDepth = CalcSceneDepth(UV);

// CoC'yi hesaplama (basit versiyon)
// Bu formül, bir pikselin odak düzlemine olan uzaklığına göre CoC'yi belirler
// Minyatür etkisi için özellikle "Odak Mesafesi" ve "Aperture" önemlidir.
float DepthRatio = (FocalDistance * FocalLength) / (Aperture * (PixelDepth - FocalDistance));
float CoC = abs(DepthRatio);

// CoC'yi normalize etme ve maksimum yarıçap ile sınırlama
CoC = min(CoC, MaxCoCRadius);

// CoC değerini görselleştirin
// return float4(CoC / MaxCoCRadius, CoC / MaxCoCRadius, CoC / MaxCoCRadius, 1.0);

// Henüz bulanıklık uygulamazsak, sadece orijinal rengi döndür
return SceneColorInput;

Bu kod bloğunda, FocalLength ve Aperture gibi değerleri materyal parametreleri olarak tanımlayarak dışarıdan kontrol edebiliriz. MaxCoCRadius ise uygulayacağımız maksimum bulanıklık miktarını kontrol eder. CoC değerini hesapladıktan sonra, onu MaxCoCRadius ile karşılaştırarak bir üst limit getiriyoruz. Bu, çok uzak veya çok yakın objelerin aşırı bulanıklaşmasını engeller ve daha estetik bir kontrol sağlar.

Minyatür tarzı DoF için, özellikle belirgin bir odak düzlemi ve bu düzlemin hızla dışına çıkan bulanıklık isteriz. Bu nedenle, CoC değerini, odak düzleminin etrafında belirli bir "netlik bandı" oluşturacak şekilde manipüle etmek önemlidir. Yani, odak mesafesine çok yakın pikseller için CoC sıfıra yakınken, odak mesafesinden uzaklaştıkça CoC hızla artar. Bu matematiksel temel, bir sonraki adımda bulanıklığı gerçekte nasıl uygulayacağımızı belirleyecektir. Her pikselin CoC değeri, kaç örnekleme noktasının alınacağını veya bulanıklık filtresinin boyutunu doğrudan etkileyecektir.

Öte yandan, bu basit formüller genellikle ideal lens modelleri için geçerlidir. Gerçek dünyada lens kusurları (bokeh şekli, renk sapmaları) DoF efektini daha da karmaşıklaştırır. Ancak, minyatür tarzı bir etki için, CoC'yi basitleştirilmiş bir yaklaşımla hesaplamak genellikle yeterli ve daha performanslıdır. Esas olan, odaklanmış alana hızlı geçişli, belirgin bir bulanıklık eğrisi yakalamaktır.

Minyatür Stili için Odaklama ve Bulanıklık Uygulaması

CoC değerini hesapladığımıza göre, artık bu bilgiyi kullanarak pikselleri nasıl bulanıklaştıracağımızı görme zamanı. Minyatür tarzı bir DoF efekti için, bulanıklığın yumuşak ve doğal görünmesi, ancak aynı zamanda keskin bir geçişle odaklanmış alanı vurgulaması önemlidir. Bu, genellikle çevredeki piksellerden örnekleme yaparak ve bu örnekleri CoC değerine göre ağırlıklandırarak elde edilir.

Bulanıklık uygulamak için birden fazla strateji vardır: basit kutu bulanıklık (box blur), Gaussian bulanıklık (Gaussian blur) veya daha gelişmiş, bokeh efektleri üretebilen disk/altıgen tabanlı bulanıklık. Minyatür tarzı bir efekt için, hafif bir Gaussian veya basit bir disk bulanıklığı genellikle yeterli ve performans dostudur. Temel fikir, bir pikselin CoC değeri ne kadar büyükse, o kadar geniş bir alandan örnek alıp ortalamalarını almaktır.

Aşağıdaki HLSL kodu, CoC değerine dayalı basit bir disk bulanıklığı uygulamanın temelini gösterir. MaxBlurAmount parametresi, bulanıklığın ne kadar geniş bir alana yayılacağını kontrol eder.

// Unreal Engine Custom Node içinde bulanıklık uygulama

// Giriş parametreleri
float4 SceneColorInput; 
float SceneDepthInput; 
float FocalDistance;     
float FocalLength;       
float Aperture;          
float MaxCoCRadius;      // Maksimum CoC yarıçapı (piksel cinsinden)
float SampleCount;       // Bulanıklık için alınacak örnek sayısı (örneğin, 8 veya 16)
float2 TextureSize;      // Ekran doku boyutu (örneğin, 1920, 1080)

float2 UV = GetScreenPosition().xy / GetScreenPosition().w;
float PixelDepth = CalcSceneDepth(UV);

// CoC hesaplaması (önceki bölümden)
float DepthRatio = (FocalDistance * FocalLength) / (Aperture * (PixelDepth - FocalDistance));
float CoC = abs(DepthRatio);
CoC = min(CoC, MaxCoCRadius);

// CoC 0'a yakınsa (yani odak içinde), bulanıklık yok
if (CoC < 0.01f) // Eşik değeri
{
    return SceneColorInput;
}

// Bulanıklık uygulaması: Disk veya halka şeklinde örnekleme
float4 BlurredColor = float4(0,0,0,0);
float TotalWeight = 0.0f;

// Örnekleme yarıçapını CoC değerine göre ayarla
float SampleRadius = CoC / TextureSize.x; // UV uzayında CoC
float AngleStep = (2.0f * PI) / SampleCount;

for (int i = 0; i < SampleCount; ++i)
{
    float Angle = AngleStep * i;
    float2 SampleOffset = float2(cos(Angle), sin(Angle)) * SampleRadius;
    float2 SampleUV = UV + SampleOffset;

    // Sınır kontrolü (isteğe bağlı, kenarlarda bozulmayı önler)
    if (SampleUV.x >= 0.0f && SampleUV.x <= 1.0f &&
        SampleUV.y >= 0.0f && SampleUV.y <= 1.0f)
    {
        float4 SampleColor = SceneTextureLookup(SampleUV, 0); // SceneTexture (PostProcessInput0)
        
        // Basit ağırlıklandırma (isteğe bağlı)
        // float SampleDepth = CalcSceneDepth(SampleUV);
        // float SampleCoC = abs((FocalDistance * FocalLength) / (Aperture * (SampleDepth - FocalDistance)));
        // float Weight = 1.0f - saturate(abs(CoC - SampleCoC) / MaxCoCRadius); // Bulanıklık uyumu
        float Weight = 1.0f; // Şimdilik eşit ağırlık

        BlurredColor += SampleColor * Weight;
        TotalWeight += Weight;
    }
}

if (TotalWeight > 0.0f)
{
    return BlurredColor / TotalWeight;
}
else
{
    return SceneColorInput; // Eğer örnekleme yapılamazsa orijinal rengi döndür
}

Bu kod bloğu, SampleCount kadar çevresel pikselden örnek alır ve bunları toplayarak bulanık bir renk elde eder. SampleRadius, CoC değerine göre belirlenir, böylece bulanıklık miktarı dinamik olarak değişir. SceneTextureLookup fonksiyonu, PostProcessInput0 olarak tanımlanan ana sahne dokusundan renk örneklemesi yapar. Örnek UV koordinatlarını hesaplarken, TextureSize değerini kullanarak CoC'yi piksel biriminden UV birimine dönüştürdüğümüzden emin olmalıyız. PI değeri ise 3.14159 olarak tanımlanmalıdır (HLSL'de genellikle PI sabiti yoktur, kendiniz tanımlayabilirsiniz).

Bu yöntem, her piksel için bağımsız bulanıklık hesaplamaları yaptığı için performansı optimize etmek kritik öneme sahiptir. Özellikle SampleCount değeri, performansı doğrudan etkiler. Daha düşük değerler daha az bulanıklık ancak daha iyi performans sunar. Gerçek minyatür tarzı DoF efekti için, bulanıklığın sadece odak düzleminin dışında ve belirgin bir eğriyle artması gerektiğini unutmayın.

Bu temel bulanıklık algoritması, efektin kalitesini artırmak için daha da geliştirilebilir. Örneğin, bokeh şekillerini simüle etmek için örnekleme desenleri değiştirilebilir veya bulanıklığı daha da iyileştirmek için iki geçişli (separable) bulanıklık teknikleri kullanılabilir. Ancak, bu basit disk bulanıklığı bile minyatür etkisi için oldukça yeterli bir başlangıç noktası sunar. Özellikle minyatür estetiği için, bulanıklığın pürüzsüz ve "oyuncak" gibi görünmesi hedeflenir, bu da çok yüksek kaliteli bokeh efektlerinden ziyade genel bir bulanıklık hissini öne çıkarır.

Performans Optimizasyonu ve İleri Düzey Minyatür DoF Efektleri

Özel bir DoF shader'ı oluşturmak heyecan verici olsa da, gerçek zamanlı uygulamalarda performans kritik bir faktördür. Özellikle yüksek çözünürlüklerde veya mobil platformlarda, her piksel için birden fazla örnekleme yapmak GPU üzerinde önemli bir yük oluşturabilir. Minyatür DoF efektimizin kalitesini artırırken performansı nasıl koruyabiliriz? Ayrıca, daha ileri düzeyde görsel çekicilik için neler ekleyebiliriz?

Performans Optimizasyonu Stratejileri:

1. Downsampling (Aşağı Örnekleme): En etkili yöntemlerden biridir. Bulanıklık efektini, sahnenin daha düşük çözünürlüklü bir kopyası üzerinde uygulayıp, daha sonra yüksek çözünürlüklü çıktıya yükseltmektir. Örneğin, bulanıklığı yarı çözünürlükte hesaplayarak, piksel örnekleme sayısını önemli ölçüde azaltabiliriz. Bu, genellikle iki aşamalı bir yaklaşımla yapılır: ilk geçişte sahne renk ve derinlik tamponları downsample edilir, ikinci geçişte bu downsample edilmiş verilere bulanıklık uygulanır.
2. Separable Blur (Ayırılabilir Bulanıklık): Özellikle Gaussian bulanıklık için kullanılan bu teknikte, bulanıklık yatay ve dikey olmak üzere iki ayrı geçişte uygulanır. Bu, N örneklemeli bir bulanıklığın karmaşıklığını N*N'den 2N'e düşürerek performansı büyük ölçüde artırır. Minyatür DoF efektlerinde, CoC'ye dayalı olarak bulanıklık genişliği değiştiği için uygulaması biraz daha karmaşık olsa da, genel bir bulanıklık pass'ı olarak kullanılabilir.
3. Compute Shader'lar: Daha karmaşık bulanıklık algoritmaları veya dinamik CoC tabanlı örnekleme desenleri için Compute Shader'lar güçlü bir alternatif sunar. Compute Shader'lar, GPU'nun genel işlem birimlerini kullanarak paralel hesaplamalar yapabilir ve böylece piksel shader'ların sınırlamalarını aşabilir. Bu, özellikle büyük ölçekli ve yüksek kaliteli bokeh efektleri için idealdir.
4. Sadece Gerekli Alanları Bulanıklaştırma: CoC değeri sıfıra yakın olan (yani odaklanmış) pikseller için bulanıklık hesaplamalarını atlayın. Kodumuzda zaten basit bir if (CoC < 0.01f) kontrolü bulunuyor. Bu, gereksiz GPU döngülerinden tasarruf sağlar.

İleri Düzey Efektler ve Kalite Artırımı:

1. Bokeh Efektleri: Gerçek kamera lenslerindeki diyafram şeklini (genellikle altıgen veya sekizgen) taklit eden parlak bulanıklık noktalarıdır. Bunu elde etmek için, bulanıklık örnekleme desenini disk yerine altıgen bir desene göre ayarlayabilir veya daha gelişmiş teknikler (örneğin, splatting tabanlı bokeh) kullanabiliriz.
2. Chromatic Aberration (Renksel Sapma): Lens kusurlarının bir taklidi olarak, bulanıklaşan bölgelerin kenarlarında renk ayrışmaları eklemek, efektin gerçekçiliğini artırabilir. Genellikle, farklı renk kanallarını (R, G, B) biraz farklı ofsetlerle örnekleyerek elde edilir.
3. Foreground/Background Blur Ayrımı: Odak düzleminin önündeki objeler genellikle daha büyük ve farklı bir bulanıklık karakteristiğine sahip olabilir. Daha gelişmiş DoF sistemleri, ön plan ve arka plan bulanıklığını ayrı ayrı işleyerek bu ayrımları yapabilir. Bu, derinlik tamponunun dikkatli bir şekilde analiz edilmesini gerektirir.
4. Temporal AA ile Entegrasyon: DoF efektleri genellikle jaggies (tırtıklı kenarlar) ve titremelerle sonuçlanabilir. Temporal Anti-Aliasing (TAA) ile entegrasyon, bu görsel kusurları gidermeye yardımcı olabilir ve daha pürüzsüz bir sonuç verir.

Vaka Analizi: Sanatsal Bir Yaklaşım

Birçok bağımsız oyun ve sanat projesi, minyatür tarzı DoF'u benzersiz bir estetik yaratmak için kullanır. Örneğin, belirli strateji oyunları veya simülasyon oyunları (örneğin, "Cities: Skylines" veya "Mini Motorways" gibi), genel görünümlerini bir masa üstü model veya oyuncak setine benzetmek için bu efekti benimser. Bu oyunlarda, DoF sadece bir kamera efekti olmaktan çıkar, aynı zamanda oyunun ölçek algısını ve kullanıcı deneyimini doğrudan etkileyen bir sanatsal araç haline gelir. "The Witness" gibi oyunlar da belirli alanlara odaklanmak ve oyuncunun dikkatini yönlendirmek için DoF'u akıllıca kullanır, ancak bu oyunların DoF'u genellikle minyatürden ziyade sinematik bir stile sahiptir. Bizim "minyatür" hedefimiz için, daha belirgin ve agresif bir CoC eğrisi ile, odaklanmış alanın hemen dışında hızlı bir bulanıklık artışı arıyoruz. Bu, izleyicide gerçek dünyadaki bir maket fotoğrafı hissini uyandırır.

Mobil uyumluluk için, yukarıda belirtilen optimizasyon teknikleri daha da hayati hale gelir. Mobil cihazların sınırlı GPU gücü nedeniyle, yüksek SampleCount değerlerinden kaçınmak ve her zaman downsampling gibi agresif optimizasyonları kullanmak gerekir. CSS media query örneğimiz makalenin genel görünümünü mobil cihazlara uyarlasa da, HLSL shader'ınızın kendisi için de benzer "seviye düşürme" stratejileri düşünmelisiniz: düşük kaliteli cihazlarda daha az örnekleme, daha basit bulanıklık algoritmaları ve hatta DoF'u tamamen devre dışı bırakma gibi seçenekler sunulabilir.

Minyatür DoF ile Görsel Hikaye Anlatımınızı Güçlendirin

Unreal Engine ve HLSL kullanarak özel minyatür tarzı bir Alan Derinliği (DoF) efekti oluşturma yolculuğumuzun sonuna geldik. Bu süreç boyunca, genel DoF kavramlarından, HLSL ile temel matematiksel hesaplamaların nasıl yapılacağına ve son olarak bulanıklık uygulama ve performans optimizasyonlarına kadar geniş bir yelpazeyi ele aldık. Gördüğünüz gibi, hazır çözümlerin ötesine geçmek, size projenizin görsel kalitesi ve sanatsal yönü üzerinde eşsiz bir kontrol sağlar.

Minyatür DoF, sadece teknik bir başarı olmanın ötesinde, oyunlarınıza veya görselleştirmelerinize benzersiz bir karakter katma potansiyeli taşır. Bir sahneyi küçük bir maket veya oyuncak gibi göstermek, izleyicinin algısını manipüle ederek hikaye anlatımınıza derinlik katar. Oyuncunun dikkatini belirli bir noktaya çekebilir, sahnenin ölçeğiyle oynayabilir veya sadece görsel olarak çarpıcı bir estetik yaratabilirsiniz. Unutmayın, bu tür özel efektler, projenizin akılda kalıcılığını artırarak onu rakiplerinden ayırabilir.

Özel bir shader geliştirmek, ilk başta karmaşık görünebilir, ancak temel prensipleri anladığınızda, sınırsız yaratıcı olasılıklar sunar. Kendi CoC hesaplamanızı, bulanıklık algoritmanızı ve optimizasyon stratejilerinizi belirleyerek, tam olarak istediğiniz görsel çıktıyı elde edebilirsiniz. Deney yapmaktan çekinmeyin! Farklı FocalDistance, Aperture ve MaxCoCRadius değerleri ile oynayarak, projenize en uygun minyatür estetiği bulmak için çeşitli kombinasyonlar deneyin.

Bu süreç, sadece bir efekt oluşturmakla kalmaz, aynı zamanda Unreal Engine'in rendering pipeline'ını ve GPU programlamasını daha derinlemesine anlamanıza da yardımcı olur. Elde ettiğiniz bu bilgi, gelecekteki projelerinizde karşılaşacağınız diğer görsel zorlukların üstesinden gelmeniz için güçlü bir temel oluşturacaktır. Yaratıcılığınızı serbest bırakın ve kendi küçük dünyalarınızı inşa edin!

Sıkça Sorulan Sorular