Unity Mathf Sınıfı Metodları ve Özellikleri
Bu yazımızda Unity Mathf sınıfı içerisinde yer alan metodlara ve özellikleri inceleyerek, basit örneklerde nasıl kullanabileceğinize değineceğiz. Math sınıfından bir metod(Methods) ya da özellik(Properties) kullanmadan önce bu yazıyı bir kaynak olarak kullanabilirsiniz.
Statik Özellikler (Static Properties)
Mathf.Deg2Rad
Mathf.LinearToGammaSpace metodu, doğrusal renk uzayından gama düzeltmesi yapılmış renk uzayına dönüştürme işlemi yapar.
Bir RGB rengi için her bir bileşenin (kırmızı, yeşil, mavi) doğrusal bir renk uzayındaki değerleri 0 ile 1 arasındadır. Ancak bu değerler, gerçek dünyadaki görüntüyü yansıtmak için uygun bir şekilde düzenlenmemiştir. Bu nedenle, RGB renkleri genellikle gamma düzeltmesi uygulanarak dönüştürülür.
Kullanımı şu şekildedir:
Color gammaCorrectedColor = Mathf.LinearToGammaSpace(linearColor);
Burada, linearColor doğrusal renk uzayındaki bir RGB rengidir. Fonksiyon, renk bileşenlerini gama düzeltmesi yapılmış değerlerle değiştirir ve bu değerleri tutan yeni bir renk nesnesi döndürür.
Örneğin, bir renk bileşeninin 0.5 olduğunu varsayarsak, bu, doğrusal renk uzayında, ışık yoğunluğunun yarısı anlamına gelir. Ancak, gerçek dünyadaki ışık yoğunluğu ve algılamamız, doğrusal bir şekilde değil, gama fonksiyonu ile bağlantılıdır. Bu nedenle, doğru bir görüntü elde etmek için renk bileşenleri gamma düzeltmesi ile düzenlenir.
Bu metodun kullanımı, özellikle grafik programlama ve görüntü işleme gibi alanlarda çok yaygındır.
Mathf.Epsilon
Mathf.Epsilon, 1.0’e en yakın kayan noktalı sayıdır. Bu değer çok küçük olduğu için, genellikle sıfıra yakın değerlerin doğruluğunu kontrol etmek için kullanılır.
Örneğin, iki kayan noktalı sayının eşit olup olmadığını kontrol etmek için, aralarındaki farkın Mathf.Epsilon değerinden küçük veya eşit olup olmadığına bakılabilir. Bu yöntem, kayan noktalı sayıların hassasiyeti nedeniyle doğru sonuçlar elde etmek için sık sık kullanılır.
Örneğin, aşağıdaki gibi bir kontrol yapılabilir:
float a = 0.1f + 0.2f;
float b = 0.3f;
if (Mathf.Abs(a - b) <= Mathf.Epsilon) {
Debug.Log("a ve b birbirine eşittir.");
} Burada, a değişkeni 0.30000004 ve b değişkeni 0.3 olarak atanmıştır. Ancak, kayan noktalı sayıların hassasiyeti nedeniyle, a ve b arasındaki farkı doğrudan karşılaştırmak doğru sonucu vermeyebilir. Bunun yerine, farkın Mathf.Epsilon değerinden küçük veya eşit olup olmadığına bakarak, a ve b’nin eşit olup olmadığını kontrol edebiliriz.
Mathf.Infinity
Mathf.Infinity, kayan noktalı sayılar arasında sonsuz pozitif sayıyı temsil eden bir sabittir. Bu değer, bir hesaplama sırasında sonucun sonsuzluğa ulaştığını göstermek için kullanılabilir.
Örneğin, aşağıdaki örnekte, bir oyuncunun can değerinin sonsuz olması durumunda yapılacak bir kontrol gösterilmektedir:
public float health = Mathf.Infinity;
void Update() {
if (health == Mathf.Infinity) {
Debug.Log("Oyuncunun canı sonsuzdur.");
}
} Bu örnekte, health değişkeni varsayılan olarak sonsuz pozitif olarak ayarlanır. Her güncelleme çağrısında, sağlık değeri sonsuz pozitif olduğunda, bir hata iletisi gösterilir. Bu örnek, oyuncunun ölümsüz olduğu veya özel bir durumda olduğu senaryoları ele almak için kullanılabilir.
Mathf.NegativeInfinity
Mathf.NegativeInfinity, kayan noktalı sayılar arasında sonsuz negatif sayıyı temsil eden bir sabittir. Bu değer, bir hesaplama sırasında sonucun negatif sonsuzluğa ulaştığını göstermek için kullanılabilir.
Örneğin, aşağıdaki örnekte, bir değerin negatif sonsuz olduğu durumda yapılacak bir kontrol gösterilmektedir:
public float value = Mathf.NegativeInfinity;
void Start() {
if (value == Mathf.NegativeInfinity) {
Debug.Log("Değer negatif sonsuzdur.");
}
} Bu örnekte, value değişkeni varsayılan olarak negatif sonsuz olarak ayarlanır. Başlangıçta, value değeri negatif sonsuz olduğu için bir hata iletisi gösterilir. Bu örnek, özel bir durumda veya bir hata durumunda bir değerin negatif sonsuz olduğunu kontrol etmek için kullanılabilir.
Mathf.PI
Mathf.PI, sabit bir kayan noktalı sayıdır ve π (pi) matematiksel sabitinin yaklaşık değerini temsil eder. π, bir dairenin çevresinin çapına oranı olarak tanımlanır ve matematiksel hesaplamaların birçok yerinde kullanılır.
float radius = 5f;
float area = Mathf.PI * Mathf.Pow(radius, 2);
Debug.Log("Dairenin alanı: " + area); Bu örnekte, bir dairenin alanını hesaplamak için önce yarıçapını belirtirsiniz. Sonra, Mathf.PI sabiti kullanarak π’nin değerini alırsınız. Son olarak, yarıçapın karesini hesaplamak için Mathf.Pow() yöntemini kullanır ve π’nin karesi ile çarparak dairenin alanını hesaplar.
Mathf.PI, matematiksel hesaplamaların birçok yerinde kullanılabilir ve özellikle dairelerle ilgili hesaplamalarda sıkça kullanılır.
Mathf.Rad2Deg
Mathf.Rad2Deg, sabit bir kayan noktalı sayıdır ve radyan cinsinden açıların dereceye dönüştürülmesinde kullanılır. Radyanlar, açıların ölçümünde kullanılan birimlerden biridir ve daire üzerindeki merkezi açının yayının uzunluğu ile oranı olarak tanımlanır. Dereceler ise bir tam dairenin 360 eşit parçaya ayrıldığı ve her parçanın 1 derece olduğu birimlerdir.
float radianAngle = Mathf.PI / 4f; // 45 derece açıya karşılık gelen radyan açısı
float degreeAngle = radianAngle * Mathf.Rad2Deg;
Debug.Log("Açının derece cinsinden değeri: " + degreeAngle); Bu örnekte, önce 45 derece açıya karşılık gelen radyan açısı olan Mathf.PI/4f değeri atanır. Daha sonra, Mathf.Rad2Deg sabiti kullanılarak bu radyan açısı dereceye dönüştürülür ve sonuç olarak açının derece cinsinden değeri hesaplanır.
Mathf.Rad2Deg, radyanlarla çalışan işlemlerde kullanışlı bir sabittir ve özellikle açıların derece cinsinden gösterilmesi gereken durumlarda kullanılabilir.
Statik Metodlar (Static Methods)
Mathf.Abs Metodu
Mathf.Abs, aldığı parametrenin mutlak değerini (pozitif değerini) döndüren bir fonksiyondur. Bu fonksiyon, bir sayının negatif mi pozitif mi olduğundan bağımsız olarak, her zaman pozitif bir değer döndürür.
Örneğin, Mathf.Abs fonksiyonu aşağıdaki gibi kullanılabilir:
float a = -5.5f;
float b = Mathf.Abs(a);
Debug.Log("a'nın mutlak değeri: " + b); Bu örnekte, ilk olarak bir float değişkeni olan a’ya -5.5f değeri atanır. Daha sonra, Mathf.Abs fonksiyonu kullanılarak a’nın mutlak değeri hesaplanır ve sonuç olarak 5.5f değeri döndürülür.
Mathf.Abs fonksiyonu, bir sayının mutlak değerinin hesaplanmasında kullanışlıdır ve özellikle fizik tabanlı hesaplamalar, grafik işlemleri veya herhangi bir sayının uzaklığı gibi durumlarda kullanılabilir.
Mathf.Acos Metodu
Mathf.Acos, verilen bir açının kosinüsünün tersini alarak, bu açının derece cinsinden arccosine değerini döndüren bir matematik fonksiyonudur.
Bu fonksiyon, [-1, 1] aralığındaki bir sayıyı girdi olarak alır ve [0, π] aralığındaki bir açı çıktı olarak döndürür. Bu çıktı, verilen girdi değerinin kosinüsü olarak düşünülebilir.
Örneğin, Mathf.Acos fonksiyonu aşağıdaki gibi kullanılabilir:
float x = 0.5f;
float angle = Mathf.Acos(x) * Mathf.Rad2Deg;
Debug.Log("Arccosine değeri: " + angle); Bu örnekte, ilk olarak bir float değişkeni olan x’e 0.5f değeri atanır. Daha sonra, Mathf.Acos fonksiyonu kullanılarak x’in arccosine değeri hesaplanır ve sonuç olarak radyan cinsinden 1.0471975f değeri döndürülür.
Daha sonra, bu açı derece cinsine dönüştürülerek, sonuç olarak 60.0f değeri döndürülür. Bu örnekte, 0.5f değeri için arccosine değeri 60.0 derecedir.
Mathf.Acos fonksiyonu, trigonometrik hesaplamalar, 3D matematiksel işlemler ve grafik işlemleri gibi durumlarda kullanışlıdır.
Mathf.Approximately Metodu
Mathf.Approximately, Unity’de kullanılan bir matematiksel fonksiyondur ve iki sayının hemen hemen eşit olup olmadığını kontrol eder.
Matematikte, iki sayının tam olarak eşit olması çok nadirdir ve sıklıkla özetleme ya da yaklaşık değerlerle çalışılır. Bu nedenle, Mathf.Approximately fonksiyonu, sayıların belirli bir hassasiyetle yaklaşık olarak eşit olup olmadığını kontrol eder.
Fonksiyon, iki parametre alır:
- birinci sayı (a)
- ikinci sayı (b)
- hassasiyet (epsilon) – isteğe bağlı olarak belirtilebilir ve varsayılan değeri 0.00001’dir.
Örneğin, aşağıdaki kodda Mathf.Approximately fonksiyonu, a ve b değişkenlerinin yaklaşık olarak eşit olup olmadığını kontrol eder:
float a = 1.0f; float b = 1.00001f; bool approximatelyEqual = Mathf.Approximately(a, b);
Bu durumda, approximatelyEqual değişkeni true (doğru) olacaktır, çünkü a ve b değişkenleri, 0.00001 hassasiyetle yaklaşık olarak eşittir.
Yani, Mathf.Approximately fonksiyonu, hassasiyetle yaklaşık olarak eşitlik kontrolü yapmak istediğimiz durumlarda kullanışlı bir fonksiyondur.
Mathf.Asin Metodu
Mathf.Asin, Unity’de kullanılan bir matematiksel fonksiyondur ve parametre olarak aldığı sayının arkus sinüsünü (inverse sine) döndürür.
Örneğin, aşağıdaki kodda Mathf.Asin fonksiyonu, x değişkeninin sinüsünü hesaplar ve bu değere karşılık gelen açıyı radian cinsinden angle değişkenine atar:
float x = 0.5f; float angle = Mathf.Asin(x);
Bu durumda, x değişkeninin sinüsü 0.5 olduğundan, angle değişkeninin değeri yaklaşık 0.5236 radian olacaktır.
Yani, Mathf.Asin fonksiyonu, bir sayının sinüsü verildiğinde, bu sayıya karşılık gelen açıyı bulmak istediğimiz durumlarda kullanışlı bir fonksiyondur.
Mathf.Atan Metodu
Mathf.Atan, Unity’de kullanılan bir matematiksel fonksiyondur ve parametre olarak aldığı sayının arkus tanjantını (inverse tangent) döndürür.
Matematiksel olarak, arkus tanjant, bir değerin tanjant fonksiyonunun aldığı değere karşılık gelen açıdır. Yani, Mathf.Atan fonksiyonu, bir açının tanjantı verilen bir sayıyı alır ve bu açıyı radyan cinsinden döndürür.
Örneğin, aşağıdaki kodda Mathf.Atan fonksiyonu, x değişkeninin tanjantını hesaplar ve bu değere karşılık gelen açıyı radian cinsinden angle değişkenine atar:
float x = 0.5f; float angle = Mathf.Atan(x);
Bu durumda, x değişkeninin tanjantı yaklaşık olarak 0.4636 olduğundan, angle değişkeninin değeri yaklaşık olarak 0.4636 radian olacaktır.
Yani, Mathf.Atan fonksiyonu, bir sayının tanjantı verildiğinde, bu sayıya karşılık gelen açıyı bulmak istediğimiz durumlarda kullanışlı bir fonksiyondur.
Mathf.Atan2 Metodu
Mathf.Atan2, Unity’de kullanılan bir matematiksel fonksiyondur ve iki parametre alır: y ve x. Bu iki parametre, noktanın koordinat düzlemindeki konumunu belirler ve Mathf.Atan2 fonksiyonu, bu konumda yer alan noktanın açısını (radyan cinsinden) hesaplar.
Özellikle, Mathf.Atan2 fonksiyonu, y ve x koordinatları arasındaki açıyı hesaplar ve bu açıyı radyan cinsinden döndürür. Bu açı, x eksenine göre pozitif yönde (saat yönünde) ölçülür.
Örneğin, aşağıdaki kodda Mathf.Atan2 fonksiyonu, (y, x) koordinatlarındaki noktanın açısını radian cinsinden döndürür:
float y = 1.0f; float x = 1.0f; float angle = Mathf.Atan2(y, x);
Bu durumda, (y, x) koordinatlarındaki noktanın açısı yaklaşık olarak 0.7854 radian (45 derece) olacaktır.
Yani, Mathf.Atan2 fonksiyonu, koordinat düzlemindeki noktanın açısını bulmak istediğimiz durumlarda kullanışlı bir fonksiyondur.
Mathf.Ceil Metodu
Mathf.Ceil, Unity’de kullanılan bir matematik fonksiyonudur ve parametre olarak aldığı ondalıklı sayıyı, en yakın daha büyük tam sayıya yuvarlar.
Örneğin, aşağıdaki kodda Mathf.Ceil fonksiyonu, x değişkeninin değerini en yakın daha büyük tam sayıya yuvarlar:
float x = 2.6f; float result = Mathf.Ceil(x);
Bu durumda, x değişkeninin değeri 2.6 olduğundan, result değişkeninin değeri 3 olacaktır.
Yani, Mathf.Ceil fonksiyonu, bir ondalıklı sayıyı en yakın daha büyük tam sayıya yuvarlamak istediğimiz durumlarda kullanışlı bir fonksiyondur.
Mathf.CeilToInt Metodu
Mathf.CeilToInt, Unity’de kullanılan bir matematik fonksiyonudur ve parametre olarak aldığı ondalıklı sayıyı, en yakın daha büyük tam sayıya yuvarlayarak, tam sayı olarak döndürür.
Örneğin, aşağıdaki kodda Mathf.CeilToInt fonksiyonu, x değişkeninin değerini en yakın daha büyük tam sayıya yuvarlar ve bu tam sayı değerini result değişkenine atar:
float x = 2.5f; int result = Mathf.CeilToInt(x);
Bu durumda, x değişkeninin değeri 2.5 olduğundan, result değişkeninin değeri 3 olacaktır.
Yani, Mathf.CeilToInt fonksiyonu, bir ondalıklı sayıyı en yakın daha büyük tam sayıya yuvarlayarak, tam sayı olarak döndürmek istediğimiz durumlarda kullanışlı bir fonksiyondur.Regenerate response
Mathf.Clamp Metodu
Mathf.Clamp, Unity’de kullanılan bir matematik fonksiyonudur ve bir değeri, belirli bir aralıkta kısıtlamak için kullanılır. Bu fonksiyon, üç parametre alır: değer (value), alt sınır (min) ve üst sınır (max).
Fonksiyon, önce değer parametresinin alt sınır ile karşılaştırması yapar ve daha küçükse alt sınır değeri alınır. Daha sonra, değer parametresi üst sınır ile karşılaştırılır ve daha büyükse, üst sınır değeri alınır. Eğer değer parametresi, alt sınır ve üst sınır arasında ise, değer parametresi direkt olarak kullanılır.
Örneğin, aşağıdaki kodda Mathf.Clamp fonksiyonu, x değişkeninin değerini 1 ile 5 arasındaki bir değer olarak kısıtlar:
float x = 3.0f; float result = Mathf.Clamp(x, 1.0f, 5.0f);
Bu durumda, x değişkeninin değeri 3.0 olduğundan, result değişkeninin değeri de 3.0 olacaktır.
Eğer x değişkeninin değeri 6 olsaydı, Mathf.Clamp fonksiyonu, bu değeri üst sınır olan 5 ile değiştirir ve result değişkeninin değeri de 5 olurdu.
Yani, Mathf.Clamp fonksiyonu, bir değeri belirli bir aralıkta kısıtlamak istediğimiz durumlarda kullanışlı bir fonksiyondur.
Mathf.Clamp01 Metodu
Mathf.Clamp01, Unity’de kullanılan bir matematik fonksiyonudur ve bir değeri 0 ile 1 arasında bir aralıkta kısıtlamak için kullanılır.
Bu fonksiyon, sadece bir parametre alır: değer (value).
Fonksiyon, önce değer parametresinin 0 ile karşılaştırması yapar ve daha küçükse 0 değeri alınır. Daha sonra, değer parametresi 1 ile karşılaştırılır ve daha büyükse, 1 değeri alınır. Eğer değer parametresi, 0 ve 1 arasında ise, değer parametresi direkt olarak kullanılır.
Örneğin, aşağıdaki kodda Mathf.Clamp01 fonksiyonu, x değişkeninin değerini 0 ile 1 arasındaki bir değer olarak kısıtlar:
float x = 1.5f; float result = Mathf.Clamp01(x);
Bu durumda, x değişkeninin değeri 1.5 olduğundan, result değişkeninin değeri de 1.0 olacaktır. Çünkü, 1 değeri 1 ile karşılaştırıldığında daha büyük olduğu için, 1 değeri alınır.
Eğer x değişkeninin değeri -0.5 olsaydı, Mathf.Clamp01 fonksiyonu, bu değeri alt sınır olan 0 ile değiştirir ve result değişkeninin değeri de 0 olurdu.
Yani, Mathf.Clamp01 fonksiyonu, bir değeri 0 ile 1 arasında bir aralıkta kısıtlamak istediğimiz durumlarda kullanışlı bir fonksiyondur.
Mathf.ClosestPowerOfTwo Metodu
Mathf.ClosestPowerOfTwo, Unity’de kullanılan bir matematik fonksiyonudur ve bir sayının en yakın 2’nin üssüne yuvarlanmasını sağlar.
Örneğin, 11 sayısı, en yakın 2’nin üssü olan 8’e yuvarlanır. Bu durumda, Mathf.ClosestPowerOfTwo fonksiyonu, 11 sayısını 8 sayısıyla değiştirir.
Fonksiyon, yalnızca bir parametre alır: sayı (number). Fonksiyon, sayı parametresini 2’nin üssü olan bir sayıya yuvarlar. Eğer sayı parametresi, 2’nin üssüne eşitse, direk sayı parametresi kullanılır.
Örneğin, aşağıdaki kodda Mathf.ClosestPowerOfTwo fonksiyonu, x değişkeninin değerini en yakın 2’nin üssüne yuvarlar:
int x = 11; int result = Mathf.ClosestPowerOfTwo(x);
Bu durumda, x değişkeninin değeri 11 olduğundan, result değişkeninin değeri de 8 olacaktır.
Eğer x değişkeninin değeri 16 olsaydı, Mathf.ClosestPowerOfTwo fonksiyonu, bu değeri doğrudan kullanır ve result değişkeninin değeri de 16 olurdu.
Yani, Mathf.ClosestPowerOfTwo fonksiyonu, bir sayıyı en yakın 2’nin üssüne yuvarlamak istediğimiz durumlarda kullanışlı bir fonksiyondur.
Mathf.CorrelatedColorTemperatureToRGB Metodu
Mathf.CorrelatedColorTemperatureToRGB, Unity’de kullanılan bir matematik fonksiyonudur ve verilen sıcaklık değerine göre bir renk oluşturur. Bu renk, RGB renk uzayında ifade edilir.
Bu fonksiyon, yalnızca bir parametre alır: sıcaklık (temperature). Sıcaklık parametresi, kelvin cinsinden verilir. Fonksiyon, sıcaklık parametresine göre bir renk oluşturur.
Örneğin, aşağıdaki kodda Mathf.CorrelatedColorTemperatureToRGB fonksiyonu, 4000K sıcaklık değerine göre bir renk oluşturur:
float temperature = 4000f; Color color = Mathf.CorrelatedColorTemperatureToRGB(temperature);
Bu durumda, fonksiyon, 4000K sıcaklık değerine karşılık gelen bir renk oluşturur ve bu renk, color değişkenine atanır.
Fonksiyon, sıcaklık parametresine göre bir renk oluşturmak için standart bir algoritma kullanır. Bu algoritma, sıcaklık değerinin verilmiş bir aralıkta olup olmadığına göre farklı renkler oluşturur.
Örneğin, 1000K’dan düşük bir sıcaklık değeri verildiğinde, fonksiyon siyah bir renk döndürür. 2000K’den düşük, 6500K’den yüksek bir sıcaklık değeri verildiğinde ise fonksiyon beyaz bir renk döndürür.
Yani, Mathf.CorrelatedColorTemperatureToRGB fonksiyonu, verilen bir sıcaklık değerine göre bir renk oluşturmak istediğimiz durumlarda kullanışlı bir fonksiyondur.
Mathf.Cos Metodu
Tabanı Euler sayısı e olan cosinüs fonksiyonunu hesaplar. Aldığı parametre radyan cinsinden bir açıdır ve sonucu float türünde döndürür.
Cosinüs fonksiyonu, bir üçgenin kosinüs teoremi ile ilişkilidir. Bu teoreme göre, bir üçgenin bir açısının kosinüsü, bu açının karşısındaki kenarın uzunluğu ile diğer iki kenarın uzunluklarına göre hesaplanabilir. Cosinüs fonksiyonu, bir açının kosinüs değerini hesaplamak için kullanılabilir.
Mathf.Cos fonksiyonu, matematiksel bir işlem yaparak verilen açının kosinüs değerini hesaplar. Örneğin, aşağıdaki kod, 60 derecelik bir açının kosinüs değerini hesaplar:
float cosValue = Mathf.Cos(Mathf.Deg2Rad * 60);
Bu durumda, Mathf.Deg2Rad sabiti kullanılarak 60 derece, radyan cinsinden ifade edilir ve Mathf.Cos fonksiyonu bu açının kosinüs değerini hesaplar. Sonuç olarak, cosValue değişkenine atanır.
Mathf.Cos fonksiyonu, trigonometrik hesaplamalar için sıklıkla kullanılır. Örneğin, 3D grafik uygulamalarında, nesnelerin konumunu, rotasyonunu ve ölçeklerini hesaplamak için trigonometrik fonksiyonlar kullanılır. Cosinüs fonksiyonu da bu hesaplamalarda sıklıkla kullanılır.
Mathf.DeltaAngle Metodu
Mathf.DeltaAngle metodu, iki açı arasındaki farkı hesaplar ve sonucu float türünde döndürür. Bu metot, açıları karşılaştırırken, bir açının diğerine göre hangi yöne doğru döndüğünü belirlemek için kullanılır.
Bu metod, farklı açı birimleri ile kullanılabilir. Örneğin, açılar derece cinsinden verilmişse, Mathf.DeltaAngle metoduna önce bu açıların radyan cinsinden ifade edilmesi gerekir. Açılar radyan cinsinden verilmişse, doğrudan Mathf.DeltaAngle metodu kullanılabilir.
Mathf.DeltaAngle metodunun kullanımı şu şekildedir:
float angleDiff = Mathf.DeltaAngle(angle1, angle2);
Bu kod, angle1 ve angle2 açıları arasındaki farkı hesaplar ve sonucu angleDiff değişkenine atar.
Bu metot, iki açının farkını hesaplamak için kullanıldığı için, sonuç her zaman pozitif bir değer değildir. Örneğin, 350 derece ile 10 derece arasındaki fark, 20 derecedir. Ancak Mathf.DeltaAngle metodu ile hesaplandığında, sonuç -340 derece olarak verilir.
Mathf.DeltaAngle metodu, özellikle oyun ve grafik programlamasında, nesnelerin konumları, rotasyonları ve hareketleri gibi açılarla ilgili hesaplamalarda sıklıkla kullanılır.
Mathf.Exp Metodu
Mathf.Exp metodu, verilen float değerinin e tabanındaki üssünü hesaplar ve sonucu float türünde döndürür. Yani, e üzeri x işlemi olarak ifade edilen bir matematiksel fonksiyonun sonucunu verir.
Örneğin, Mathf.Exp(2) ifadesi, e üzeri 2 değerini hesaplar ve sonucu döndürür. Bu değer yaklaşık olarak 7.389 olarak bulunur.
Mathf.Exp metodu, özellikle olasılık hesaplamalarında, doğrusal olmayan işlemler içeren matematiksel modellerde ve bazı istatistiksel fonksiyonların hesaplanmasında sıklıkla kullanılır. Ayrıca, e tabanındaki üssünün hesaplanması gereken durumlarda da kullanılabilir.
Kullanımı şu şekildedir:
float result = Mathf.Exp(x);
Burada, x float türünde bir sayıdır ve e üzeri x işlemi hesaplanarak sonucu result değişkenine atanır.
Özellikle oyun programlaması alanında, e tabanındaki üssün hesaplanması, örneğin doğrusal olmayan bir hareket veya bazı fiziksel hesaplamalar için gereklidir. Bu nedenle, Mathf.Exp metodu sıklıkla bu tür hesaplamalarda kullanılır.
Mathf.FloatToHalf Metodu
Mathf.FloatToHalf metodu, verilen float tipindeki bir sayıyı yarı doğal sayı (half-precision) formatındaki bir sayıya dönüştürür. Yarı doğal sayı, IEEE 754 standardında tanımlanan bir kayan noktalı sayı formatıdır ve 16 bit kullanarak ondalık sayıları temsil eder. Bu format, float tipine göre daha az bellek kullanır ve bazı durumlarda yeterli doğruluk sağlayabilir.
Kullanımı şu şekildedir:
ushort result = Mathf.FloatToHalf(floatValue);
Burada, floatValue dönüştürülecek float tipindeki sayıdır ve result, yarı doğal sayı formatındaki sayıdır. Sonuç, 16 bitlik bir unsigned short türünde döndürülür.
Mathf.FloatToHalf metodu özellikle mobil cihazlar veya performansın önemli olduğu yerlerde kullanılır. Düşük bellek kullanımı ve daha az işlemci gücü gerektirmesi nedeniyle, yarı doğal sayı formatı, float tipine göre daha performanslı olabilir.
Ancak, yarı doğal sayı formatı, float tipine göre daha az doğruluk sağlar. Bu nedenle, yüksek doğruluk gerektiren hesaplamalar için float tipi tercih edilir.
Mathf.Floor Metodu
Mathf.Floor metodu, verilen float veya double tipindeki sayının en büyük tam sayıya (integer) eşit veya küçük olan değerini döndürür. Yani, sayının ondalık kısmını atarak tam sayıya yuvarlar.
Örneğin, Mathf.Floor(3.7f) ifadesi, 3.7 sayısının en büyük tam sayıya eşit veya küçük olan değeri olan 3 değerini döndürür. Benzer şekilde, Mathf.Floor(-2.3f) ifadesi, -2.3 sayısının en büyük tam sayıya eşit veya küçük olan değeri olan -3 değerini döndürür.
Mathf.Floor metodu, özellikle matematiksel hesaplamalar veya işlem sonuçlarının tam sayıya yuvarlanması gerektiği durumlarda kullanılır. Örneğin, belirli bir uzunluğun tam sayıya yuvarlanması, nesnelerin konumlarının tam sayıya yuvarlanması veya belirli bir sürenin tam sayıya yuvarlanması gibi durumlarda kullanılabilir.
Kullanımı şu şekildedir:
float result = Mathf.Floor(x);
Burada, x float veya double tipinde bir sayıdır ve en büyük tam sayıya eşit veya küçük olan değeri hesaplanarak sonucu result değişkenine atanır.
Ayrıca, Mathf.FloorToInt metodu da mevcuttur. Bu metot, Mathf.Floor metoduna benzer şekilde çalışır, ancak sonucu int tipinde döndürür. Bu metot, float veya double tipindeki sayıyı en büyük tam sayıya eşit veya küçük olan değere yuvarlar ve sonucu int tipinde döndürür.
Mathf.GammaToLinearSpace Metodu
Mathf.GammaToLinearSpace metodu, bir renk değerinin gamma düzeltmesini yani gamma ışıklandırma modelinden doğrusal ışıklandırma modele dönüştürmeyi sağlayan bir matematiksel işlemdir. Gamma düzeltmesi, monitörlerdeki ve diğer aygıtlardaki renk değerlerinin doğrusal olmayan bir şekilde ele alınmasından kaynaklanan bir problemdir.
Gamma düzeltmesi, görüntüyü daha iyi görsel kaliteye sahip hale getirmek için kullanılır. Mathf.GammaToLinearSpace metodu, gamma düzeltmesi uygulanmış bir renk değerini doğrusal ışıklandırma modele dönüştürerek daha doğru bir renk değeri elde etmemizi sağlar.
Kullanımı şu şekildedir:
Color linearColor = Mathf.GammaToLinearSpace(gammaColor);
Burada, gammaColor, gama düzeltmesi uygulanmış bir renk değeridir. Bu renk değeri, Mathf.GammaToLinearSpace metodu kullanılarak doğrusal ışıklandırma modele dönüştürülür ve elde edilen sonuç, linearColor değişkenine atanır.
Mathf.GammaToLinearSpace metodu, genellikle grafik uygulamalarında ve video işleme işlemlerinde kullanılır.
Mathf.HalfToFloat Metodu
Mathf.HalfToFloat metodu, yarı doğal sayı formatındaki (half-precision) bir kayan nokta sayısını, tam doğal sayı formatındaki (single-precision) bir kayan nokta sayısına dönüştürmek için kullanılan bir matematiksel işlemdir.
Yarı doğal sayı formatı (half-precision), IEEE 754 standardı tarafından tanımlanan kayan nokta sayı formatlarından biridir. Bu format, 16 bitlik bir sayı kullanarak, sıfırdan farklı çok küçük ve çok büyük sayıları temsil edebilir. Tam doğal sayı formatı (single-precision), yine IEEE 754 standardı tarafından tanımlanan bir başka kayan nokta sayı formatıdır ve daha yüksek bir doğruluk sağlamak için 32 bitlik bir sayı kullanır.
Mathf.HalfToFloat metodu, yarı doğal sayı formatındaki bir sayıyı alır ve tam doğal sayı formatındaki bir sayıya dönüştürür. Kullanımı şu şekildedir:
float floatNumber = Mathf.HalfToFloat(halfNumber);
Burada, halfNumber, yarı doğal sayı formatındaki bir sayıdır. Bu sayı, Mathf.HalfToFloat metodu kullanılarak tam doğal sayı formatındaki bir sayıya dönüştürülür ve elde edilen sonuç, floatNumber değişkenine atanır.
Mathf.HalfToFloat metodu, genellikle grafik uygulamalarında ve video işleme işlemlerinde kullanılır. Yarı doğal sayı formatı, tam doğal sayı formatına göre daha az bellek kullanır ve daha hızlı işlem yapar, bu nedenle bu format, özellikle mobil cihazlarda ve diğer düşük güçlü aygıtlarda kullanılır.
Mathf.InverseLerp Metodu
Mathf.InverseLerp metodu, bir minimum ve maksimum aralığında, bir noktanın nerede olduğunu yüzde olarak hesaplamak için kullanılan bir matematiksel fonksiyondur. Örneğin, 0 ile 10 arasındaki bir sayının yüzde olarak 5’te olduğunu hesaplamak için kullanılabilir.
Kullanımı şu şekildedir:
float result = Mathf.InverseLerp(min, max, value);
Burada, min ve max, aralığın minimum ve maksimum değerleridir. value ise, hesaplanmak istenen noktanın değeridir.
İşlem sonucunda, result değişkeni, değerin minimum ve maksimum aralıkta nerede olduğunu yüzde olarak ifade eder. Eğer value, min ve max aralığının dışında bir değerse, sonuç değeri 0 ile 1 arasında olacaktır. Eğer value, min’den küçükse, sonuç 0’dan küçük olabilir ve eğer value, max’tan büyükse, sonuç 1’den büyük olabilir.
Örneğin, 0 ile 100 arasındaki bir sayının yüzde olarak 75’te olduğunu hesaplamak için, şu şekilde kullanılabilir:
float result = Mathf.InverseLerp(0, 100, 75);
Bu işlem sonucunda, result değişkeni 0.75 değerini alacaktır.
Mathf.IsPowerOfTwo Metodu
Mathf.IsPowerOfTwo metodu, verilen bir tam sayının 2’nin üssü olup olmadığını kontrol etmek için kullanılır. Bu metod, tam sayıların 2’nin üssü olup olmadığını hızlı bir şekilde kontrol etmek için kullanılabilir.
Kullanımı şu şekildedir:
bool result = Mathf.IsPowerOfTwo(value);
Burada, value değişkeni kontrol edilmek istenen tam sayıdır. İşlem sonucunda, result değişkeni, value’nun 2’nin üssü olup olmadığını gösteren bir boolean değer alır. Eğer value, 2’nin bir üssüyse (örneğin, 2, 4, 8, 16, 32 vb.), sonuç true olacaktır. Eğer value, 2’nin bir üssü değilse (örneğin, 3, 5, 6, 7, 9, 10 vb.), sonuç false olacaktır.
Örneğin, 8’in 2’nin üssü olup olmadığını kontrol etmek için şu şekilde kullanılabilir:
bool result = Mathf.IsPowerOfTwo(8);
Bu işlem sonucunda, result değişkeni true değerini alacaktır.
Mathf.Lerp Metodu
Mathf.Lerp metodu, iki sayı arasında belirli bir oranda (0 ile 1 arasında) ara bir sayı döndürmek için kullanılır. Bu yöntem, özellikle animasyonlar ve geçiş efektleri oluşturmak için kullanışlıdır.
Kullanımı şu şekildedir:
float result = Mathf.Lerp(a, b, t);
Burada, a ve b değişkenleri arasında bir ara değer hesaplanacaktır. t, 0 ile 1 arasında bir sayıdır ve a ve b arasındaki oranı belirler. Eğer t 0 ise, sonuç a olacaktır. Eğer t 1 ise, sonuç b olacaktır. Eğer t 0.5 ise, sonuç a ve b’nin ortasında (yani, (a + b) / 2) olacaktır.
Örneğin, 1 ile 10 arasındaki sayıların ortalamasını almak için şu şekilde kullanılabilir:
float result = Mathf.Lerp(1f, 10f, 0.5f);
Bu işlem sonucunda, result değişkeni 5.5 değerini alacaktır.
Mathf.LerpAngle Metodu
Mathf.LerpAngle metodu, iki açı arasında belirli bir oranda (0 ile 1 arasında) ara bir açı döndürmek için kullanılır. Bu yöntem, özellikle dönen nesnelerin açısal animasyonları veya karakterlerin yönlerini kontrol etmek için kullanışlıdır.
Kullanımı şu şekildedir:
float result = Mathf.LerpAngle(a, b, t);
Burada, a ve b arasında bir ara açı hesaplanacaktır. t, 0 ile 1 arasında bir sayıdır ve a ve b arasındaki oranı belirler. Eğer t 0 ise, sonuç a açısı olacaktır. Eğer t 1 ise, sonuç b açısı olacaktır. Eğer t 0.5 ise, sonuç a ve b’nin ortasındaki açı olacaktır.
Örneğin, 30 derece ve 60 derece arasındaki açıların ortalamasını almak için şu şekilde kullanılabilir:
float result = Mathf.LerpAngle(30f, 60f, 0.5f);
Bu işlem sonucunda, result değişkeni 45 derece değerini alacaktır.
Mathf.LerpUnclamped Metodu
Mathf.LerpUnclamped metodu, Mathf.Lerp metoduna benzer ancak sınırlama yapmaz. Yani, değerlerin belirli bir aralıkta olması gerekmez.
Kullanımı şu şekildedir:
float result = Mathf.LerpUnclamped(a, b, t);
Burada, a ve b arasında belirli bir oranda (0 ile 1 arasında) bir ara değer hesaplanacaktır. t, 0 ile 1 arasında bir sayıdır ve a ve b arasındaki oranı belirler. Eğer t 0 ise, sonuç a değeri olacaktır. Eğer t 1 ise, sonuç b değeri olacaktır. Eğer t 0.5 ise, sonuç a ve b’nin aritmetik ortalaması olacaktır.
Örneğin, 2 ve 5 arasındaki bir değeri 0.75 oranında hesaplamak için şu şekilde kullanılabilir:
float result = Mathf.LerpUnclamped(2f, 5f, 0.75f);
Bu işlem sonucunda, result değişkeni 4.25 değerini alacaktır.
LerpUnclamped metodu, özellikle animasyonlarda sınırları olmayan pürüzsüz bir geçiş sağlamak istendiğinde kullanışlıdır.
Mathf.LinearToGammaSpace Metodu
Mathf.LinearToGammaSpace metodu, doğrusal renk uzayından gama düzeltmesi yapılmış renk uzayına dönüştürme işlemi yapar.
Bir RGB rengi için her bir bileşenin (kırmızı, yeşil, mavi) doğrusal bir renk uzayındaki değerleri 0 ile 1 arasındadır. Ancak bu değerler, gerçek dünyadaki görüntüyü yansıtmak için uygun bir şekilde düzenlenmemiştir. Bu nedenle, RGB renkleri genellikle gamma düzeltmesi uygulanarak dönüştürülür.
Kullanımı şu şekildedir:
Color gammaCorrectedColor = Mathf.LinearToGammaSpace(linearColor);
Burada, linearColor doğrusal renk uzayındaki bir RGB rengidir. Fonksiyon, renk bileşenlerini gama düzeltmesi yapılmış değerlerle değiştirir ve bu değerleri tutan yeni bir renk nesnesi döndürür.
Örneğin, bir renk bileşeninin 0.5 olduğunu varsayarsak, bu, doğrusal renk uzayında, ışık yoğunluğunun yarısı anlamına gelir. Ancak, gerçek dünyadaki ışık yoğunluğu ve algılamamız, doğrusal bir şekilde değil, gama fonksiyonu ile bağlantılıdır. Bu nedenle, doğru bir görüntü elde etmek için renk bileşenleri gamma düzeltmesi ile düzenlenir.
Bu metodun kullanımı, özellikle grafik programlama ve görüntü işleme gibi alanlarda çok yaygındır.
Kaynak: