Unity Mathf Sınıfı özellikle int, float gibi sayı tipleri üzerinde, trigonometri hesaplamalarında bize çeşitli fonksiyonlar sağlayan statik bir sınıftır. Bu sınıf aracılığıyla sayı değerlerinizi zamanla yumuşatmak veya bir açının sinüs değerini elde etmek gibi çeşitli işlemler gerçekleştirmeniz mümkündür.
Bunun dışında, renk, vector gibi bileşenlerde de bunları kullanmanız mümkün. Çünkü bu değişkenler de aslında kendi içerisinde float tipinde değişkenler barındırmakta. Yaptığım örneklerde de özellikle Vector3 üzerinden pozisyon değiştirme konularına değindim. Ancak direkt olarak Vector3 sınıfını kullarak da bu işlemleri başarmanız mümkün. Eğer ilgilenirseniz, “Unity Vector3 Nedir?” yazımıza göz atmanızı öneririm.
Unity Mathf Sınıfı ile Kullanılabilecek Kodlar
Unity Mathf Sınıfı ile Kullanılabilecek Kodlar temel olarak ikiye ayrılabilir. Bunlar, direkt olarak değerler içeren Properties yani özellikler ve statik fonksiyonlardır. Fonksiyonlara dair örnekler oluşturdum, ancak benzer kullanımlara sahip kodlar için, özellikle uzun olanlarda tekrar tekrar aynı kullanımı göstermeyeyim istedim. Bu yüzden hepsinin altında örnek bulamayabilirsiniz, ancak emin olun önceki veya sonraki bir fonksiyon da aynı yapıda ve aynı örneği kullanabilirsiniz.
Unity Mathf Sınıfı Properties
Unity Mathf Sınıfı Properties içerisinde, yazının devamında da ilk olarak göreceğiniz gibi, aslında sonsuzluk, Pi gibi genelde matematik işlemlerinde ihtiyaç duyabileceğimiz değişkenler bulunmaktadır.
Deg2Rad: Bu değişken ile elde ettiğimiz sabit değer aslında derece cinsinden açı değerlerini radyan cinsine çevirmemizi sağlar. Bunun için sadece elde ettiğimi açı değeriyle bu değeri çarpmak yeterli olacaktır.
Epsilon: Float tipinde 0’dan sonraki en küçük sayı değeridir.
Infinity: Sonsuzluk değerini elde etmemizi sağlar.
NegativeInfinity: Negatif yönlü sonsuzluk değeri elde etmemizi sağlar..
PI: Özellikle geometri ve çember, daire ve küre işlemlerinde sık kullandığımız 3.14…. şeklinde devam pi(π) sayı değerini elde etmemizi sağlar.
Rad2Deg: Deg2Rad özelliği gibi, bu değişken aracılığıyla radyan cinsinden açı değerini derece cinsine çevirmemiz mümkündür.
void PropertiesOrnek () {
Debug.Log (derece + " derece açının radyan karşılığı:" + derece * Mathf.Deg2Rad);
Debug.Log (radyan + " radyan derece açının derece karşılığı:" + radyan * Mathf.Rad2Deg);
Debug.Log ("Pi değeri:" + Mathf.PI);
Debug.Log ("Pi değerine sahip radyan cinsi açının derece olarak karşılığı:" + Mathf.PI * Mathf.Rad2Deg);
Debug.Log ("Epsilon, yani sıfırdan sonraki en küçük değer:" + Mathf.Epsilon);
}Unity Mathf Sınıfı Fonksiyonları
Unity Mathf Sınıfı fonksiyonları ile yazının başında da bahsettiğim gibi, sayı değerini yavaş yavaş değiştirme, bir sayının istenen değerdeki üssünü elde etme gibi matematiksel işlemleri gerçekleştirmemizi sağlayan fonksiyonları içermektedir. Bu fonksiyonlar aracılığıyla baya bir yükten kurtulduğumuz söylenebilir. Bu arada altını çizmekte fayda, 4 temel işlem yani toplama, çıkarma, çarpma ve bölme işlemleri için fonksiyonlar bulunmuyor. Bu işlemleri zaten “+, -, *, /” operatörleriyle halledebiliyoruz. Aşağıda bahsedeceğimiz işlemler genelde daha geniş çaplı, karmaşık işlemleri kapsamakta.
Abs: Verilen sayının mutlak değerini elde etmemizi sağlar. Sayı doğrusunda negatif ve pozitif yönleri düşünürseniz, -1 ve 1 değeri de aynı uzunluğa sahiptir. Abs ile bu yön bilgisinden kutulup yalnızca büyüklüğünü elde etmiş oluruz.
void AbsOrnek () {
//ikisi de 10 değerini, yani mutlak değerlerini döndürecektir.
Debug.Log (Mathf.Abs (10));
Debug.Log (Mathf.Abs (-10));
}Acos: Arkkosinüs, yani kosinüs işleminin tersini verir. Kosinüs ile nasıl açı değerini verip bir sayı değeri elde ediyorsak, bu fonksiyona da sayı değeri vererek, ilgili açı değerini radyan cinsinden elde etmemizi sağlar.
void AcosOrnek () {
//Mathf.Acos radyan cinsinden döndürdüğü için bunu Rag2Deg ile dereceye çeviriyoruz
Debug.Log ("Cos değeri 1 olan açı:" + Mathf.Acos (1) * Mathf.Rad2Deg);
Debug.Log ("Cos değeri 0 olan açı:" + Mathf.Acos (0f) * Mathf.Rad2Deg);
}Approximately: Verilen 2 sayının birbirine yakın, denk olup olmadıklarını elde etmemizi sağlar. Özellikle float tipindeki sayılarda, “==” ifadesi ile kontrol sağladığımızda, değişkenler birbirine çok yakın olsa da doğru değerini vermeyebilir. Bu tarz yakınlık durumunu kontrol etmek ve işlemin istediğimiz gibi çalıştığından emin olmamızı sağlayan bir fonksiyondur. Eğer sayılar birbirine çok yakın, denk ise true değeri döndürür. Örnekte de bu iki durumun karşılaştırmasını yapıyoruz aslında. Sadece start içerisinde değil, update içerisinde çalıştırırsanız, == komutunun bazen false döndürdüğüne denk gelebilirsiniz. Karşılaşma oranı düşük olabilir ama, bahsettiğim fonksiyon ile bu karşılaştırma durumunu garanti altına alıyoruz.
void ApproximatelyOrnek () {
Debug.Log ("10f/10f ile 1f birbirine eşittir:" + (1.0f == 10.0f / 10.0f));
Debug.Log ("10f/10f ile 1f değerine birine denktir, çok yakındır" + Mathf.Approximately (1.0f, 10.0f / 10.0f));
}Asin: Arksinüs, yani sinüs işleminin tersidir. Verdiğimiz sayı değerinin sinüs karşılığı olan açı değerini radyan cinsinden bize döndürür.
void AsinOrnek () {
//Mathf.Asin radyan cinsinden döndürdüğü için bunu Rag2Deg ile dereceye çeviriyoruz
Debug.Log ("Sin değeri -1 olan açı:" + Mathf.Asin (1) * Mathf.Rad2Deg);
Debug.Log ("Sin değeri .5f olan açı:" + Mathf.Asin (.5f) * Mathf.Rad2Deg);
}Atan: Arktanjant, yani tanjant işlemin tersidir. Verdiğimiz sayı değerinin tanjant karşılığı olan açıyı radyan cinsinden bize döndürür.
void AtanOrnek () {
//Mathf.Atan radyan cinsinden döndürdüğü için bunu Rag2Deg ile dereceye çeviriyoruz
Debug.Log ("Tan değeri -1 olan açı:" + Mathf.Atan (0) * Mathf.Rad2Deg);
Debug.Log ("Tan değeri .5f olan açı:" + Mathf.Atan (.5f) * Mathf.Rad2Deg);
}Atan2: x ve y bileşenleri ayrı ayrı vermemizi imkan tanıyan, bu sayede 0 ile bölünme gibi durumlarına önüne de geçerek tanjantın y/x şeklinde hesaplandığı durumlarda daha doğru sonuçlar almamızı sağlayan ters tan fonksiyonudur.
public Transform kameraHedef;
void Atan2Ornek () {
//Hedefin konumunu kamera konumuna çeviriyoruz
Vector3 kamerayaGoreHedefKonum = transform.InverseTransformPoint (kameraHedef.position);
//ardından hedefin kamera localindeki x,z değerlerini elde ederek Atan2 ile kaç derecelik açı farkı olduğunu elde ediyoruz
float angle = Mathf.Atan2 (kamerayaGoreHedefKonum.x, kamerayaGoreHedefKonum.z) * Mathf.Rad2Deg;
//elde ettiğimiz açı kadar y ekseninde dönüş işlemi gerçekletiriyoruz. Aradaki farkı giderdiğimiz için kamera hedef objeye doğru bakacaktır.
transform.Rotate (0, angle, 0);
/*
burada dikkat etmeniz gereken, tek 1 eksende dönüş işlemini gerçekleştirdiğimiz.
Bunun yerine LookAt kullanmanız da mümkün. Ancak bu yöntem direkt açı değerleri
üzerinde işlem yapmanıza da imkan vermekte.
*/
}
void Update () {
Atan2Ornek ();
}Ceil: Verilen float tipindeki değere en yakın, ondan büyük veya eşit olan float tipinde tam sayıyı elde etmemizi sağlar.
void CeilOrnek () {
//10
Debug.Log (Mathf.Ceil (10f));
//11
Debug.Log (Mathf.Ceil (10.3f));
//-10
Debug.Log (Mathf.Ceil (-10.9f));
}CeilToInt: Ceil fonksiyonuyla benzer mantıkta çalışır, ancak verilen değere en yakın ve ondan büyük veya eşit tam sayıyı float tipi yerine int tipinde döndürür.
Clamp: Verilen değerin, belirtilen minimum ve maksimum değerlerini aşmadığından emin olmamızı sağlar. Bu fonksiyona verdiğimiz değer eğer belirttiğimiz sınırdan az ise, minimum değeri, sınırdan fazla ise de, belirttiğimiz maksimum değeri bize döndürür.
float posX = 0, posZ = 0;
float min = -5, max = 5;
//Input ile x ve z ekseninde objeyi hareket ettiren
//ve sınırların dışına çıkmasını engelleyen fonksiyon
void ClampOrnek () {
posX += Input.GetAxis ("Horizontal");
posZ += Input.GetAxis ("Vertical");
posX = Mathf.Clamp (posX, min, max);
posZ = Mathf.Clamp (posZ, min, max);
transform.position = new Vector3 (posX, 0, posZ);
}
void Update () {
ClampOrnek ();
}Clamp01: Clamp fonksiyonu ile aynı mantığa sahiptir, ancak sınırları 0 ve 1 olarak önceden belirlenmiştir. Eğer verilen değer sıfırdan ufaksa, 0, eğer birden büyükse 1 değerini geri döndürür.
ClosestPowerOfTwo: Verilen sayıya en yakın olan 2’nin üssü değeri bize geri döndürür.
void ClosestPowerOfTwoOrnek () {
//En yakın 2'nin üssü olan değer 4
Debug.Log (Mathf.ClosestPowerOfTwo (5));
//En yakın 2'nin üssü olan değer 8
Debug.Log (Mathf.ClosestPowerOfTwo (7));
}CorrelatedColorTemperatureToRGB: Kelvin değerinden varolan renk sıcaklığı değerini RGB türüne çevirir. Kelvin değeri olarak 1000-4000 arası değer girilebilir. Color tipinde değişken döndürür.
Cos: Radyan cinsinden verilen açı değerinin kosinüs değerini elde etmemizi sağlar. -1 ve 1 arasında değer döndürür.
public int cokgenKenarSayisi = 5;
public float cokgenYaricap = 5;
void Update () {
CokgenCiz (cokgenYaricap, cokgenKenarSayisi);
}
//Debug Line ile XZ düzleminde objeyi merkez alan ve verilen yarıçap, kenar sayısına uygun şekilde düzgün çokken çizdirmemizi sağlayan fonksiyon.
void CokgenCiz (float yaricap, int kenarSayisi) {
// The corner that is used to start the polygon (parallel to the X axis).
Vector3 baslangicKosesi = new Vector3 (yaricap, 0, 0) + transform.position;
// Önceki köşe olarak başlangıcı atıyoruz.
Vector3 oncekiKose = baslangicKosesi;
// Başlangıç köşesinden sonraki her bir köşeyi dolanıyoruz...
for (int i = 1; i < kenarSayisi; i++) {
// Köşenin açı değerini radyan cinsinden hesaplıyoruz.
float koseAcisi = 2f * Mathf.PI / (float) kenarSayisi * i;
//Belirlediğimiz açıya göre, o an yaratacağımız köşe noktasının x ve z değerlerini belirliyoruz.
//Cos ve Sin fonksiyonlarından nasıl yararlandığımıza dikkat edin.
Vector3 anlikKose = new Vector3 (Mathf.Cos (koseAcisi) * yaricap, 0, Mathf.Sin (koseAcisi) * yaricap) + transform.position;
// Önceki köşe ile şu an yarattığımız köşe noktasını kullanarak bir çizgi çiziyoruz.
Debug.DrawLine (anlikKose, oncekiKose);
// Anlık olarak yarattığımız köşeyi, onceki köşe olarak atıyoruz, böylece sonraki döngüde gelecek bu noktayı kullanabileceğiz.
oncekiKose = anlikKose;
}
// Son olarak başlangıç ve bitiş yani en son belirlediğimiz köşe noktası arasında da bir çizgi çiziyioruz.
Debug.DrawLine (baslangicKosesi, oncekiKose);
}DeltaAngle: Verilen 2 açı değeri arasındaki mesafenin en kısa halini elde etmemizi sağlar. Örneğin bir dairede, 360 derece ile, 0 derecesi aynı açıyı elde etmemizi sağlayacaktır. Yani aralarındaki fark aslında 0 denilebilir. Ancak 360-0 diyerek bunu elde etmeye çalışırken, alacağımız değer istediğimizden fazla olacaktır. DeltaAngle ile bu en kısa mesafeyi veren açı değerini elde ettiğimiz söylenebilir.
void DeltaAngleOrnek () {
// -90
Debug.Log (Mathf.DeltaAngle (180, 90));
// 90
Debug.Log (Mathf.DeltaAngle (360, 90));
}Exp: Bu fonksiyon, bir diğer matematiksel sabit olan “e” değerinin verdiğimiz değerdeki üssünü elde etmemizi sağlar.
void ExpOrnek () {
Debug.Log (Mathf.Exp (2));
Debug.Log (Mathf.Exp (4));
}Floor: Verdiğimiz sayıyaya en yakın ve ondan daha küçük olan tam sayı değerini float cinsinden bize verir.
void FloorOrnek () {
//20
Debug.Log (Mathf.Floor (20.0F));
//20
Debug.Log (Mathf.Floor (20.9F));
//-21
Debug.Log (Mathf.Floor (-20.01F));
}FloorToInt: Floor fonksiyonu ile aynı şekilde, verdiğimiz sayıya en yakın ve ondan daha küçük olan tam sayıyı verir, ancak int tipinde döndürür.
GammaToLinearSpace: Verilen gamma düzlemindeki sayı değerinin linear düzlemindeki değerine erişmemizi sağlar.
InverseLerp: Verdiğimiz değerin, başlangıç ve bitiş değerleri arasındaki hangi konumda olduğunu elde etmemizi sağlar. Eğer verdiğimiz değer, başlangıç değerine eşit ise 0, eğer bitiş değerine eşit ise 1 değerini döndürecektir.
Vector3 baslangic = Vector3.zero, bitis = Vector3.right * 10;
/*
Sidescroll-2d bir haritada, karakterin başlangıç ve bitiş arasındaki
mesafenin yüzde kaçında olduğunu elde etmemizi sağlayan fonksiyon.
*/
void InverseLerpOrnek () {
float yolYuzde = Mathf.InverseLerp (baslangic.x, bitis.x, transform.position.x);
//InverseLerp değerinin 0-1 arasında değer döndürüyor.
// Yüzde değerini elde etmek için bunu 100 ile çarparak 0-100 aralığına genişletiyoruz.
Debug.Log ("Yolunda %" + yolYuzde * 100 + " kısmı tamamlandı.");
}IsPowerOfTwo: Verdiğimiz değerin 2’nin üssü olup olmadığını elde etmemizi sağlar, eğer 2’nin üssü ise true, yoksa false değer döndürür.
void IsPowerOfTwo () {
//false
Debug.Log (Mathf.IsPowerOfTwo (18));
//true
Debug.Log (Mathf.IsPowerOfTwo (32));
}Lerp: Başlangıç ve bitiş değerlerini verdiğimiz ve bu iki değer arasında hangi noktadan değer elde etmek istediğimizi belirttiğimiz bir fonksiyondur. İki değer arasındaki nokta için verdiğimiz değer 0 ise başlangıç değerini, 1 ise bitiş değerini elde etmemizi sağlar. Eğer arasında bir değer verirsek de, örneğin .5, tam olarak iki değerin ortasında bulunan değeri bize döndürür.
float saglik = 5, saglikMax = 15;
float saglikYenilemeHizi = 1f;
void LerpOrnek () {
if (saglik < saglikMax) {
//sağlığın maksimum sağlık ile varolan oranının elde ediyoruz. 0-1 arası bir değer veriyor bize.
float varolanOran = saglik / saglikMax;
/*
daha sonrasında, sağlığı arttırmak istediğimiz için, hedef oran hesaplamasını yapıyoruz.
Burada saglikYenilemeHizi/saglikMax işlemi yapmamızın sebebi, direkt artış değeri değil,
oran kullanıyor olmamız.
Time.deltaTime ile çarparak da, belirlediğimiz artış oranını tam olarak 1 saniyede
gerçekleştirmemize olanak veriyor.
*/
float hedefOran = varolanOran + Time.deltaTime * (saglikYenilemeHizi / saglikMax);
/*
Minumum olarak 0 değerini ve maksimum olarak saglikMax değerini kullanıyoruz
verdiğimiz oran da bu ikisi arasında gitmemizi sağlıyor. En başta
saglik/saglikMax işlemin yapma sebebimiz de aslında
0-1 arasında bir oran elde etmek.
*/
saglik = Mathf.Lerp (0, saglikMax, hedefOran);
//debug yerine bir slider kullanarak ekranda görmeniz de mümkün. Slider maks değerini saglikMax ile eşitlemeyi unutmayın tabii.
Debug.Log (saglik);
}
}
void Update () {
LerpOrnek ();
}LerpAngle: Lerp gibi çalışır, ancak açılarda özellikle 360 derece tam tur dönüldüğü, bu değerin geçilmesi durumlarına göre hesaplanarak, açılar için daha doğru değerler elde etmemizi sağlar.
float baslangicAci = 0.0f;
float bitisAci = 450.0f;
void LerpAngleOrnek () {
float aci = Mathf.LerpAngle (baslangicAci, bitisAci, Time.time);
transform.eulerAngles = new Vector3 (0, aci, 0);
}
void Update () {
LerpAngleOrnek ();
}LerpUnclamped: Lerp gibi çalışır, ancak vereceğimiz oran değeri, 1’den fazla veya 0’dan az olabilir. Yani sınırlama ortadan kalkar. Ancak başlangıç bitiş değeri arasındaki değer farkından oluşan değişimi koruyarak bu sınırların dışında da hareket etmesini sağlar.
LinearToGammaSpace: Verilen linear düzlemindeki sayı değerinin gamma düzlemindeki değerine erişmemizi sağlar.
Log: Verilen sayının belirtilen tabandaki logaritmasını elde etmemizi sağlar.
void LogOrnek () {
//8'in 2 tabanındaki logaritması
Debug.Log (Mathf.Log (8, 2));
//100'ün e sabiti tabanında logaritması, 2.değişkeni belirtmediğimiz taban olarak e sabitini kullanır.
Debug.Log (Mathf.Log (100));
}Log10: Verilen sayının onluk tabanda logaritmasını elde etmemizi sağlar.
Max: Verilen 2 değerden en büyük olanı elde etmemizi sağlar.
Min: Verilen 2 değerden en küçük olanı elde etmemizi sağlar.
void MinMaxOrnek () {
float a = .25f, b = 1.5f;
//1.5f
Debug.Log (Mathf.Max (a, b));
//.25f
Debug.Log (Mathf.Min (a, b));
}MoveTowards: Verilen değerden, hedeflenen değere doğru, belirttiğimiz artış miktarıyla değişim olmasını sağlar. Lerp ile benzer işleve sahiptir, ancak Lerp ile başlangıç hedef arası konum oranını verirken, burada direkt olarak değişimin miktarını belirtiriz.
float anlikSaglik = 5;
float maxSaglik = 25;
float iyilesmeHizi = 2;
void MoveTowardsOrnek () {
//Anlik sağlık değerinden, maxSaglik değerine her karede verdiğimiz değer kadar artış sağlıyoruz.
anlikSaglik = Mathf.MoveTowards (anlikSaglik, maxSaglik, iyilesmeHizi * Time.deltaTime);
Debug.Log ("Anlık Sağlık:" + anlikSaglik);
}
void Update () {
MoveTowardsOrnek ();
}MoveTowardsAngle: MoveTowards ile benzer şekilde çalışır, ancak özellikle, 360 derece açılı tam tur durumlarının aşılması durumunda, doğru hesaplamanın yapılmasını sağlar. Açı işlemleri için bunu kullanmanız önerilir.
NextPowerOfTwo: Verilen değere eşit veya ona yakın olan 2’nin üssü değerini elde etmemizi sağlar.
void NextPowerOfTwoOrnek () {
//16
Debug.Log (Mathf.NextPowerOfTwo (15));
//32
Debug.Log (Mathf.NextPowerOfTwo (17));
}PerlinNoise: Perlin Noise oluşturmamızı sağlar. Özellikle “procedural generation” olarak karşımıza çıkabilecek, mağara, zindan, arazi yapılarında doğal bir rastgelelik etmemiz için noise kullanmak önemlidir. 2 boyutlu bir noise map üzerinde, verdiğimi x ve y konumundaki değerin ne olacağını bize döndürür. 0 ve 1 arasında float cinsinde değer döndürür.
[SerializeField]
float objeMiktarı = 25, noiseScale = 10;
//PerlinNoise ile farklı yüksekliklere sahip objelerden bir grid yapısı oluşturmamızı sağlayan yapı.
void Start () {
for (int x = 0; x < objeMiktarı; x++) {
for (int z = 0; z < objeMiktarı; z++) {
GameObject kup = GameObject.CreatePrimitive (PrimitiveType.Cube);
//perlin noise için x,z koordinatlarını hesaplıyoruz
float xCoord = x / objeMiktarı * noiseScale;
float zCoord = z / objeMiktarı * noiseScale;
//hesapladığımız koordinatlar ile noise değerini alıyoruz
float posY = Mathf.PerlinNoise (xCoord, zCoord);
//noise değerini Y ekseni olarak pozisyona veriyoruz.
kup.transform.position = new Vector3 (x, posY, z);
}
}
}PingPong: Zamanla 0 ile verilen değer arasında gidip gelme efekti elde sağlayan bir fonksiyondur.
float hedefNokta = 8, hareketHiziCarpani = 2;
//x pozisyonunda 0 ve hedefnokta arasında gidip gelme hareketini sağlayan kod
//0 pozisyonunu değiştiremiyoruz, yani başlangıç değerini belirtemiyoruz maalesef.
void PingPongOrnek () {
float posX = Mathf.PingPong (Time.time * hareketHiziCarpani, hedefNokta);
transform.position = new Vector3 (posX, 0, 0);
}
void Update () {
PingPongOrnek ();
}Pow: Verilen değişkenin herhangi bir üs değerini elde etmemizi sağlar.
void PowOrnek () {
//2 üssü 1.5
Debug.Log (Mathf.Pow (2, 1.5f));
}Repeat: Verilen sayı değeri ile 0 arasında başa sarıp tekrar eden bir değişim elde etmemizi sağlar.
void RepeatOrnek () {
//x ekseninde 3 konumuna gidip, sonrasında tekrar 0'dan başlamasını sağlıyoruz.
float posX = Mathf.Repeat (Time.time, 3);
transform.position = new Vector3 (posX, transform.position.y, transform.position.z);
}
void Update () {
RepeatOrnek ();
}Round : Verilen değere en yakın tam sayı değerini float cinsinden elde etmemizi sağlar. Eğer sayının ondalıklı kısım .5 şeklinde ise, sayının kendisi ve yakın olan sayının hangisi çift ise, o tam sayıyı döndürür.
void RoundOrnek () {
// 11
Debug.Log (Mathf.Round (10.7f));
// 10
Debug.Log (Mathf.Round (10.5f));
// 12
Debug.Log (Mathf.Round (11.5f));
}RoundToInt Verilen sayıya en yakın tam sayı değerini int cinsinden elde etmemizi sağlar.
Sign: Verilen değerin negatif veya pozitiflik durumunu elde etmemizi sağlar. Eğer değer 0 veya pozitif değer ise 1, negatif ise -1 döndürür.
void SignOrnek () {
Debug.Log (Mathf.Sign (-10));
Debug.Log (Mathf.Sign (10));
}Sin: Radyan cinsinden verilen açının sinüs değerini elde etmemizi sağlar. -1 veya 1 değeri döndürür.
SmoothDamp : Var Olan değeri, istenen hedef değere istenilen sürede ulaştırır.
Transform hedef;
float smoothTime = 0.3f;
float yVelocity = 0.0f;
//hedef transform bileşenini Y ekseninde takip eden fonksiyon
void SmoothDampOrnek () {
float posY = Mathf.SmoothDamp (transform.position.y, hedef.position.y, ref yVelocity, smoothTime);
transform.position = new Vector3 (transform.position.x, posY, transform.position.z);
}
void Update () {
SmoothDampOrnek ();
}SmoothDampAngle: Var Olan açı değerini, istenen hedef değere istenilen sürede ulaştırır.
SmoothStep: Verilen maksimum ve minimum değer arasında verilen oranda değer elde etmemizi sağlar. Lerp gibi çalışır ancak minimum-maksimum noktalarına geldiğinde otomatik bir yumuşatma, yavaşlatma yaparak daha doğal bir değişim elde etmemizi sağlar.
Sqrt: Verilen değerin karekökünü elde etmemizi sağlar.
void SqrtOrnek () {
Debug.Log (Mathf.Sqrt (9));
Debug.Log (Mathf.Sqrt (16));
}Tan: Radyan cinsinden verilen açı değerinin tanjant değerini elde etmemizi sağlar.
void TanOrnek () {
Debug.Log (Mathf.Tan (.5f));
}Evet, böylelikle Unity Mathf Sınıfı nedir, hangi fonksiyonları içeriyor, bunlardan örneklerle beraber bahsetmiş oldum. Unity Mathf Sınıfı için 2019.4 sürümü dokümanından faydalandım bu yazıyı oluştururken. Yeni sürümlerde de çok farklılık olacağını sanmıyorum, ama arada dönüp göz atmanızda fayda var diye düşünüyorum. Umarım faydalı olur sizler için, sonraki yazılarda görüşmek dileğiyle.
