Unity Quaternion Sınıfı Metotları ve Özellikleri
Unity Quaternion sınıfı, dört boyutlu bir vektör olarak kullanılan rotasyonları temsil etmek için kullanılır. Quaternion sınıfı, özellikle 3D oyunlarında nesnelerin dönme hareketlerini kontrol etmek için kullanılır.
Quaternion sınıfı, Euler açıları veya rotasyon matrisleri kullanılarak oluşturulabilir ve bu rotasyonları birleştirmek, interpolasyon yapmak veya tersini almak gibi işlemler de yapılabilir. Quaternion sınıfı ayrıca, belirli bir rotasyonun tersini almak veya rotasyonların birbirine göre farkını bulmak için de kullanılabilir.
Örneğin, bir karakterin yönünü değiştirmek için Quaternion sınıfını kullanabilirsiniz. Karakterin mevcut rotasyonu, Quaternion.Euler yöntemi kullanılarak Euler açılarından bir Quaternion nesnesine dönüştürülür. Sonra yeni bir Quaternion nesnesi oluşturulur ve karakterin yönünü belirleyen açılara göre dönüştürülür. İki Quaternion nesnesi slerp veya lerp gibi yöntemlerle (lineer veya sferik bir şekilde) birbirine yaklaştırılır ve son olarak karakterin rotasyonu olarak atanır.
Quaternion Static Properties
Static Properties (Statik Özellikleri), herhangi bir nesne örneği olmadan da doğrudan erişilebilen özelliklerdir. Bu özelliklerin kullanımı, özellikle belirli değerleri elde etmek veya değiştirmek için sıklıkla kullanılır.
Unity’nin birçok sınıfı, Static Properties’leri kullanır ve bu özellikler genellikle sınıfın belirli bir özelliğini tanımlar. Örneğin, Time sınıfı, Unity oyun motorunda zamanla ilgili çeşitli bilgileri sağlar ve Time sınıfının deltaTime adlı bir Static Property’si vardır. Bu özellik, son iki frame arasındaki zaman farkını içeren bir float değeri döndürür.
Bazı diğer örnekler arasında Input sınıfının mousePosition ve GetKeyDown gibi Static Properties’leri, Screen sınıfının width ve height gibi Static Properties’leri ve Physics sınıfının gravity gibi Static Properties’leri yer alır.
Özetle, Unity’nin Static Properties’leri, belirli özelliklerin kolayca erişilmesine ve değiştirilmesine olanak tanır ve nesne örneği oluşturulmasını gerektirmez.
identity Özelliği
Unity’de Quaternion sınıfının identity özelliği, öntanımlı olarak 0,0,0,1 (x, y, z, w) değerlerine sahip olan bir Quaternion nesnesi oluşturur. Bu, hiçbir dönüşümün uygulanmadığı varsayılan bir pozisyondur.
Bu özellik, genellikle bir nesnenin varsayılan oryantasyonunu ayarlamak için kullanılır. Örneğin, bir 3B modelleme programından bir nesne aktarıyorsanız, nesnenin yönünü ayarlamak için identity Quaternion’u kullanabilirsiniz.
Aşağıdaki örnek, bir nesnenin varsayılan oryantasyonunu ayarlamak için identity Quaternion’un nasıl kullanılabileceğini göstermektedir:
using UnityEngine;
public class Example : MonoBehaviour
{
void Start()
{
// Transform the object to its default orientation
transform.rotation = Quaternion.identity;
}
} Bu kod, nesnenin varsayılan oryantasyonunu ayarlar ve nesneyi 0,0,0 pozisyonunda yerleştirir.
Quaternion Properties
Unity’de, bir sınıfın özelliklerine erişebilmek için kullanılan değişkenlere “Properties” denir. Properties’ler, genellikle private olarak tanımlanmış sınıf değişkenlerine erişim sağlamak için kullanılır. Property’ler, sınıfın verilerine dışarıdan erişimi kontrol etmek, gerekirse dönüştürmek ve değerlerin doğruluğunu kontrol etmek için kullanılabilir.
eulerAngles Özelliği
Unity Quaternion sınıfında yer alan eulerAngles, Quaternion nesnesinin dönüşümünü belirten Euler açılarını (x, y, z) vektörü olarak temsil eden bir Vector3 türünden özelliktir.
Euler açıları, nesnenin x, y ve z eksenleri etrafındaki açısal rotasyonunu temsil eder. Bu özellik, Quaternion’u kullanarak yürütülen bir dönüşümü, insanların daha kolay anlayabileceği şekilde göstermek için kullanışlıdır.
Özellik olarak kullanıldığında, Quaternion nesnesinin dönüşümü için belirtilen Euler açılarına karşılık gelen bir Vector3 değeri döndürür. Bu dönüşümü belirlemek için kullanılabilecek bir özelliktir.
Aşağıda örnek olarak, Quaternion nesnesinin dönüşümünü belirleyen Euler açıları (30, 45, 60) değerleri atanmış bir Quaternion nesnesinin eulerAngles özelliği kullanılarak elde edilen Vector3 değeri örneği verilmiştir:
using UnityEngine;
public class Example : MonoBehaviour
{
void Start()
{
Quaternion rotation = Quaternion.Euler(30, 45, 60);
Vector3 eulerAngles = rotation.eulerAngles;
Debug.Log("Euler angles: " + eulerAngles);
}
} Bu örnek, Quaternion.Euler() metodu kullanarak 30, 45 ve 60 derecelik Euler açılarına sahip bir Quaternion nesnesi oluşturur. Daha sonra, Quaternion nesnesinin eulerAngles özelliği, bu Quaternion dönüşümüne karşılık gelen bir Vector3 nesnesini oluşturmak için kullanılır. Son olarak, bu örnekte, Debug.Log() metodunu kullanarak, eulerAngles özelliği aracılığıyla elde edilen Euler açılarına karşılık gelen Vector3 nesnesi yazdırılır.
Normalized Özelliği
Unity Quaternion sınıfının Normalized özelliği, Quaternion’un uzunluğunu (magnitude) 1’e normalize eder. Böylece Quaternion’un birim uzunlukta olduğu garanti edilir.
Quaternion Normalized özelliği, Quaternion değerini değiştirmez, sadece normalizasyon işlemi sonrasında yeni bir Quaternion değeri döndürür.
Örnek olarak, bir GameObject’in rotasyonunu Quaternion ile temsil ettiğimizi varsayalım. Bu Quaternion’un birim uzunlukta olmasını istiyorsak, Normalize özelliğini kullanabiliriz:
// Rotasyonu Quaternion ile temsil eden bir GameObject örneği public GameObject myObject; // myObject'in rotasyonunu normalleştirme myObject.transform.rotation.Normalize();
Bu kod örneği, myObject’in rotasyonunu normalize eder. Yani Quaternion değerini 1’e normalize eder ve normalleştirilmiş Quaternion değerini kullanarak myObject’in rotasyonunu günceller.
Not: Normalleştirme işlemi, Quaternion’un yalnızca uzunluğunu değiştirir. Quaternion’un döndüğü yönü değiştirmez.
Örneğin, bir Quaternion değerinin normalleştirilmesinin etkisini gösteren aşağıdaki kodu inceleyelim:
// Quaternion değeri oluşturma
Quaternion rotation = new Quaternion(1.0f, 1.0f, 1.0f, 1.0f);
// Quaternion değerinin uzunluğunu hesaplama
float magnitude = Mathf.Sqrt(rotation.x * rotation.x + rotation.y * rotation.y + rotation.z * rotation.z + rotation.w * rotation.w);
// Normalleştirilmiş Quaternion değeri oluşturma
Quaternion normalizedRotation = new Quaternion(rotation.x / magnitude, rotation.y / magnitude, rotation.z / magnitude, rotation.w / magnitude);
// Normalleştirilmiş Quaternion değerini konsola yazdırma
Debug.Log("Normalized Rotation: " + normalizedRotation.ToString()); Bu örnekte, bir Quaternion değeri oluşturuyoruz ve daha sonra Quaternion değerini normalleştiriyoruz. Normalleştirilmiş Quaternion değerini de konsola yazdırıyoruz.
this[int] Özelliği
Unity Quaternion sınıfının this[int] özellikleri, bir Quaternion nesnesinin dört bileşeninden (x, y, z, w) birine erişmeyi sağlar. Bu özellik, x, y, z ve w bileşenleri için ayrı ayrı değer atamak veya değerleri okumak için kullanılabilir.
Özellik Tanımı:
- this[int index] : Quaternion bileşenlerinin dizin numarasıyla erişmek için kullanılır.
İndeks numarası 0, 1, 2, 3 için sırasıyla x, y, z, w bileşenlerine karşılık gelir.
Örnek Kullanım:
Quaternion rotation = new Quaternion(0.3f, 0.5f, 0.1f, 0.8f); float x = rotation[0]; // x = 0.3f float y = rotation[1]; // y = 0.5f float z = rotation[2]; // z = 0.1f float w = rotation[3]; // w = 0.8f rotation[1] = 0.2f; // rotation.y = 0.2f
Bu örnekte, Quaternion sınıfının this[int] özelliği, önce rotation adlı bir Quaternion nesnesi oluşturulur. Daha sonra, x, y, z ve w bileşenleri ayrı ayrı değişkenlere atılır ve this[int] özelliği kullanılarak bileşenlere erişilir. Ayrıca, y bileşeni, this[int] özelliği kullanılarak değiştirilir.
Quaternion Public Methods
Unity’de “public methods” olarak adlandırılan yöntemler, bir nesnenin dış dünyadan erişilebilir ve kullanılabilir olan metodlarıdır. Bu metodlar, bir nesnenin davranışını kontrol etmek ve özelliklerini değiştirmek için kullanılabilirler.
Public methods, sınıflar arasında iletişim kurmak için kullanılabilirler. Örneğin, bir oyun nesnesinin public methods’ları, oyuncu karakterinin hareketini kontrol etmek için diğer script’ler tarafından kullanılabilir.
Unity’de birçok farklı nesne türü vardır ve her biri kendi public methods’larını içerir. Örneğin, bir Transform nesnesinin public methods’ları, nesnenin konumunu ve dönüşünü kontrol etmek için kullanılabilir. Rigidbody nesnesinin public methods’ları, nesnenin fizik davranışını kontrol etmek için kullanılabilir.
Public methods, Unity’nin Object Oriented Programming (OOP) yapısı içinde önemli bir role sahiptir. Doğru bir şekilde kullanıldığında, nesnelerin davranışını özelleştirmek ve kontrollerini diğer script’lerle paylaşmak için güçlü bir araçtır.
Set Metodu
Unity’deki Quaternion sınıfının Set metodu, bir döndürme işlemi (rotasyon) için belirtilen eksen ve açıya göre bir Quaternion nesnesinin değerini ayarlamak için kullanılır.
Set metodu, 4 parametre alır:
- float x: Quaternion’un x bileşeni.
- float y: Quaternion’un y bileşeni.
- float z: Quaternion’un z bileşeni.
- float w: Quaternion’un w bileşeni.
Bu bileşenler, Quaternion’un döndürme işlemi sırasında nasıl hareket edeceğini belirler.
Örnek olarak, bir topun z ekseninde saat yönünde döndürülmesini düşünelim. Bu döndürme işlemi için, Quaternion sınıfının Set metodu aşağıdaki gibi kullanılabilir:
public float rotateSpeed = 50f; // dönüş hızı
void Update() {
// topu saat yönünde döndürmek için Quaternion değerini ayarla
Quaternion rotation = Quaternion.identity;
rotation.Set(0f, 0f, Mathf.Sin(Time.time * rotateSpeed), Mathf.Cos(Time.time * rotateSpeed));
// topun rotasyonunu güncelle
transform.rotation = rotation;
} Burada, Set metodu z ekseninde bir döndürme işlemi için Quaternion değerini ayarlar ve topun rotasyonunu bu değere göre günceller. Bu şekilde, top her Update() çağrısı sırasında saat yönünde döndürülür.
SetFromToRotation Metodu
Quaternion.SetFromToRotation() metodu, iki vektör arasındaki dönüşümü hesaplamak için kullanılır.
Bu metot, birinci parametre olarak başlangıç vektörünü, ikinci parametre olarak ise hedef vektörünü alır. Bu iki vektör arasındaki dönüşümü hesaplayarak, Quaternion tipinde bir sonuç döndürür.
Örnek olarak, karakterimizin bakış yönünü bir hedefe doğru çevirmek istediğimizi varsayalım. Başlangıçta karakterimizin bakış yönü (forward) Vector3.forward vektörüne eşittir. Hedefimiz ise karakterin dönüş yapması gereken yönü ifade eden başka bir Vector3 vektörü olsun. İşte bu durumda SetFromToRotation() metodu kullanarak, iki vektör arasındaki dönüşümü hesaplayabiliriz:
public Transform characterTransform;
public Transform targetTransform;
void Update() {
Vector3 direction = (targetTransform.position - characterTransform.position).normalized;
Quaternion lookRotation = Quaternion.SetFromToRotation(Vector3.forward, direction);
characterTransform.rotation = lookRotation;
} Bu örnekte, Update() metodu içinde öncelikle karakterin hedefe doğru olan yönünü hesaplamak için (targetTransform – characterTransform).normalized işlemi yapılır. Sonrasında, Quaternion.SetFromToRotation(Vector3.forward, direction) metodu kullanarak karakterin mevcut dönüşüne ek olarak hedef yönüne doğru dönüşünü hesaplar ve lookRotation değişkenine atanır. Son olarak, bu hesaplanan dönüş değeri, karakterin rotasyonuna atanır ve karakterimiz hedefe doğru bakmış olur.
SetLookRotation Metodu
Unity’deki Quaternion sınıfı, rotasyonları temsil etmek için kullanılır. Quaternion, birim çember üzerindeki bir noktayı temsil eden ve bir rotasyonu belirten dört öğeli bir vektördür. SetLookRotation() metodu, bir objenin bir hedefe doğru yönelmesi için gerekli olan rotasyonu hesaplar.
SetLookRotation() metodu, iki adet Vector3 parametresi alır. İlk parametre, objenin ileri yönlendirmesini belirler ve ikincisi hedefin konumunu belirler. Bu metot, objenin ileri yönlendirmesinin hedef konumuna doğru dönmesi için gerekli olan rotasyonu hesaplar.
Aşağıda SetLookRotation() metoduna örnek bir kullanım verilmiştir:
// Objemizin transform bileşenini referans alıyoruz. Transform objTransform = gameObject.transform; // Objemizin ileri yönlendirmesini belirleyen bir Vector3 tanımlıyoruz. Vector3 forwardDirection = new Vector3(0, 0, 1); // Objemizin konumundan bir hedef noktası belirliyoruz. Vector3 targetPosition = new Vector3(10, 0, 0); // Objemizin ileri yönlendirmesinin hedef noktasına doğru dönmesi için gereken rotasyonu hesaplıyoruz. Quaternion targetRotation = Quaternion.LookRotation(targetPosition - objTransform.position, Vector3.up); // Objemizin rotasyonunu belirlediğimiz rotasyon ile güncelliyoruz. objTransform.rotation = targetRotation;
ToAngleAxis Metodu
Unity Quaternion sınıfının ToAngleAxis metodu, bir Quaternion’ın dönüş açısını ve dönüş ekseni olarak belirtilen bir vektörü döndürür. Bu metot, bir dönüşün açısını ve eksenini bulmak için kullanılabilir.
Metodun imzası şu şekildedir:
public void ToAngleAxis(out float angle, out Vector3 axis);
Metot, angle ve axis parametrelerini, çıktı olarak verir. Quaternion nesnesinin dönüş açısı, angle parametresine atanırken, dönüş ekseni ise axis parametresine atanır.
Aşağıdaki örnek, bir Quaternion nesnesinin dönüş açısını ve dönüş ekseni olarak belirtilen bir vektörü bulur:
using UnityEngine;
using System.Collections;
public class ExampleClass : MonoBehaviour {
void Start() {
Quaternion rotation = Quaternion.Euler(45, 90, 0);
float angle;
Vector3 axis;
rotation.ToAngleAxis(out angle, out axis);
Debug.Log("Dönüş açısı: " + angle);
Debug.Log("Dönüş ekseni: " + axis);
}
} Bu örnekte, öncelikle Euler açıları kullanılarak bir Quaternion nesnesi oluşturulur. Ardından, ToAngleAxis metodu kullanılarak dönüş açısı ve dönüş ekseni bulunur. Son olarak, Debug.Log() yöntemi kullanılarak bulunan değerler konsola yazdırılır.
Bu örnekte, “Dönüş açısı: 90” ve “Dönüş ekseni: (0.707, 0.0, 0.707)” değerleri konsola yazdırılır.
ToString Metodu
Unity’deki Quaternion sınıfının ToString() metodu, Quaternion nesnesinin string bir temsilini döndürür. Bu metot, bir Quaternion nesnesinin x, y, z ve w bileşenlerini virgülle ayrılmış şekilde içeren bir dize döndürür.
Metodun imzası şöyledir:
public override string ToString();
Aşağıda bir örnek kullanım verilmiştir:
Quaternion rotation = Quaternion.Euler(0f, 45f, 0f); Debug.Log(rotation.ToString()); // Output: (0.00, 0.38, 0.00, 0.92)
Bu örnekte, Quaternion.Euler() yöntemi, euler açıları kullanarak bir Quaternion nesnesi oluşturur. Daha sonra, ToString() metodu, oluşturulan Quaternion nesnesinin string temsilini Debug.Log() yöntemi kullanarak konsola yazdırır.
ToString() metodunun farklı aşırı yüklenmiş sürümleri de vardır. Örneğin, ToString(string format) yöntemi, belirli bir biçimlendirme dizisi kullanarak Quaternion nesnesinin string bir temsilini döndürür. Bu yöntem, Quaternion’un çeşitli özelliklerini formatlamak için kullanılabilir.
Quaternion Static Methods
Unity Static Methods, Unity oyun motorunun sunduğu ve nesne oluşturmadan doğrudan çağrılabilen metotlardır. Bu metotlar, sıklıkla Unity projesinde sıklıkla kullanılan çeşitli işlevleri gerçekleştirmek için kullanılır.
Angle Metodu
Unity’de Quaternion sınıfı, dört öğeli bir dönüşümü temsil eden matematiksel bir sınıftır. Quaternion sınıfı, dönüşümleri temsil etmek için matrislere kıyasla daha hızlı ve daha doğru bir yöntem sağlar.
Quaternion.Angle() metodu, iki Quaternion arasındaki açıyı derece olarak hesaplar. Bu metot, Quaternion.AngleAxis() metoduyla kullanılarak, bir dönüşümden diğerine geçmek için gereken açıyı belirlemek için kullanılabilir.
Aşağıda Quaternion.Angle() metodunun kullanımına örnek verilmiştir:
Quaternion rotation1 = Quaternion.Euler(45, 0, 0);
Quaternion rotation2 = Quaternion.Euler(0, 45, 0);
// Quaternion.Angle() metodu ile iki Quaternion arasındaki açıyı hesaplayın
float angle = Quaternion.Angle(rotation1, rotation2);
Debug.Log("Açı: " + angle); Bu örnekte, Quaternion.Euler() metodu kullanılarak iki farklı dönüşüm oluşturulur. Daha sonra Quaternion.Angle() metodu kullanılarak bu iki dönüşüm arasındaki açı hesaplanır ve sonuç Debug.Log() metodunda yazdırılır.
AngleAxis Metodu
Unity Quaternion sınıfının AngleAxis Static Methodu, bir derece ve bir eksen belirterek bir döndürme Quaternion’ı oluşturur. Bu yöntem, bir objeyi bir eksen boyunca belirli bir dereceye kadar döndürmek istediğimiz durumlarda kullanışlıdır.
Method imzası şu şekildedir:
public static Quaternion AngleAxis(float angle, Vector3 axis);
Burada, “angle” döndürmenin açısıdır ve “axis”, döndürmenin etrafında döneceği eksenin normal vektörüdür.
Örnek olarak, bir topu yukarı doğru fırlattığımızı ve topun havada çevrildiğini hayal edelim. Bu durumda, topun çevrilme hareketini modellemek için bir Quaternion kullanabiliriz. Aşağıdaki kod parçası, topun havada dönme hareketi için bir Quaternion oluşturur:
using UnityEngine;
public class Example : MonoBehaviour
{
public float rotationSpeed = 50.0f;
void Update()
{
// topu yukarı doğru fırlatır
transform.Translate(Vector3.up * Time.deltaTime * 10.0f);
// topun havada dönme hareketi için Quaternion oluşturur
Quaternion rotation = Quaternion.AngleAxis(rotationSpeed * Time.deltaTime, Vector3.forward);
// topu döndürür
transform.rotation *= rotation;
}
} Burada, “rotationSpeed” değişkeni, topun her saniye ne kadar hızla döneceğini belirler. Bu örnekte, Quaternion’un AngleAxis methodu kullanılarak oluşturulan “rotation” Quaternion’u, topun dönme hareketini modellemek için kullanılır. Daha sonra, “transform.rotation” ile çarpılarak top döndürülür.
Dot Metodu
Unity Quaternion sınıfının Dot static methodu, iki quaternion arasındaki dot product’ı hesaplar. Bu metod, iki quaternion’un benzerliği hakkında bilgi sağlamak için kullanılabilir. Quaternion’ların benzer olması, objelerin birbirine benzer şekilde döndüğü anlamına gelir.
Method imzası şu şekildedir:
public static float Dot(Quaternion a, Quaternion b);
Burada a ve b, dot product’u hesaplanacak quaternion’ları temsil eder.
Aşağıdaki örnek, iki quaternion arasındaki dot product’u hesaplar:
Quaternion a = new Quaternion(0.5f, 0.5f, 0.5f, 0.5f);
Quaternion b = new Quaternion(0.3f, 0.3f, 0.3f, 0.8f);
float dotProduct = Quaternion.Dot(a, b);
Debug.Log("Dot product of a and b: " + dotProduct); Burada, Quaternion.Dot() metoduna a ve b quaternion’ları geçirilir ve dot product sonucu float tipinde bir değişkene atanır. Sonuç Debug.Log() metodu ile konsola yazdırılır.
Not: Quaternion.Dot() metodunun sonucu -1 ve 1 arasında bir değer alır. Eğer sonuç 1’e yakınsa quaternion’lar benzerdir. Eğer sonuç -1’e yakınsa quaternion’lar zıt yönlüdür. Eğer sonuç 0’a yakınsa quaternion’lar diğer quaternion’larla hiç benzerlik göstermez.
Euler Metodu
Unity Quaternion sınıfında yer alan Euler metodları, Quaternion nesnesini Euler açılarına dönüştürmek veya Euler açılarını Quaternion nesnesine dönüştürmek için kullanılır.
Quaternion.Euler() metodu, öklid dönüşümünde kullanılan x, y, z Euler açılarını alır ve bu açıları Quaternion nesnesine dönüştürür. Bu yöntem, Euler açılarını Quaternion nesnesine dönüştürmek için sıklıkla kullanılır.
Örneğin, bir nesne üzerinde x, y ve z eksenleri etrafında döndürme işlemi yapmak istediğinizi varsayalım. Bu durumda, Quaternion.Euler() metodunu kullanarak Euler açılarını Quaternion nesnesine dönüştürebilirsiniz:
float x = 45f; float y = 30f; float z = 15f; Quaternion rotation = Quaternion.Euler(x, y, z); transform.rotation = rotation;
Quaternion.Euler() metodu, x, y, ve z açılarını derece cinsinden alır ve bu açıları Quaternion nesnesine dönüştürür. Quaternion nesnesi daha sonra transform.rotation gibi bir dönüşüm değişkenine atanarak nesne üzerinde döndürme işlemi yapılabilir.
Quaternion.Euler() metodu, Quaternion nesnesini de Euler açılarına dönüştürebilir. Bu yöntem, Quaternion nesnesini öklid rotasyonlar olarak okunabilir hale getirerek kolaylık sağlar. Bu yöntem, Quaternion.ToEulerAngles() metodu ile birlikte kullanılabilir.
Quaternion rotation = transform.rotation;
Vector3 angles = rotation.eulerAngles;
Debug.Log("x: " + angles.x + ", y: " + angles.y + ", z: " + angles.z); Bu örnekte, transform.rotation nesnesi Quaternion tipindedir. Quaternion.Euler() metodu kullanılmadan önce, Quaternion nesnesi öklid rotasyonlara dönüştürülür. Sonra eulerAngles özelliği ile Euler açılarına erişilebilir. Debug.Log() yöntemi kullanılarak, her bir Euler açısı ayrı ayrı yazdırılabilir.
FromToRotation Metodu
Unity’de Quaternion sınıfının FromToRotation metodu, belirtilen iki vektör arasındaki rotasyonu hesaplamak için kullanılır. Bu yöntem, iki nokta arasındaki rotasyonu hesaplamak için kullanışlıdır.
Metodun imzası şöyledir:
public static Quaternion FromToRotation(Vector3 fromDirection, Vector3 toDirection);
Burada, fromDirection, başlangıç noktasındaki vektörü ve toDirection, hedef noktasındaki vektörü temsil eder.
Metod, fromDirection vektörünün toDirection vektörüne dönüştürülebilmesi için gerekli olan Quaternion rotasyonunu döndürür.
Örnek olarak, bir topun başlangıç noktasından hedefe doğru atış rotasyonunu hesaplamak istediğimizi düşünelim. Topun pozisyonu ve hedef pozisyonu belirledikten sonra, aralarındaki fark vektörünü hesaplarız ve bu iki vektörü FromToRotation metoduna parametre olarak geçirerek rotasyonu hesaplarız. Böylece topun doğru açıyla atılması sağlanır.
public Transform target;
public float speed = 5f;
void Update() {
// Topun başlangıç pozisyonunu hesaplayalım
Vector3 startPosition = transform.position;
// Hedef pozisyonunu belirleyelim
Vector3 targetPosition = target.position;
// Topun hedefe doğru olan rotasyonunu hesaplayalım
Quaternion rotation = Quaternion.FromToRotation(Vector3.forward, targetPosition - startPosition);
// Topu hedefe doğru ilerletelim
transform.position = Vector3.MoveTowards(startPosition, targetPosition, speed * Time.deltaTime);
transform.rotation = rotation;
} Burada, topun başlangıç pozisyonu, hedef pozisyonu, hareket hızı ve hedefe doğru olan rotasyon hesaplanır. Sonra topu MoveTowards metodunu kullanarak hedefe doğru hareket ettiririz. En son olarak, topun rotasyonunu hesapladığımız Quaternion rotasyonu olarak ayarlarız.
Inverse Metodu
Unity Quaternion Sınıfı Inverse metodu, Quaternion’un tersini alır. Yani, bir döndürme Quaternion’unun tersi, aynı açıda ama zıt yönde bir döndürme yapar.
Metodun imzası şu şekildedir:
public void Inverse()
Bu metod, Quaternion’u doğrudan değiştirir ve yeni bir Quaternion döndürmez.
Örnek olarak, bir nesneyi x ekseninde 90 derece döndürmek için bir Quaternion oluşturalım:
Quaternion rotation = Quaternion.Euler(90, 0, 0);
Daha sonra, bu Quaternion’un tersini alarak nesneyi -90 derece yönünde döndürebiliriz:
rotation.Inverse();
Quaternion, bu çağrıdan sonra, nesneyi tam ters yönde -90 derece döndürmek için kullanılabilir.
Lerp Metodu
Unity Quaternion sınıfının Lerp metodu, iki Quaternion arasında belirli bir oranda (t) doğrusal bir şekilde interpolasyon yapar. Bu, nesnelerin belirli bir yörünge boyunca hareket ettiğinde doğal bir animasyon sağlamak için kullanılabilir.
Metodun imzası şu şekildedir:
public static Quaternion Lerp(Quaternion a, Quaternion b, float t);
Burada a ve b, arasındaki interpolasyon yapılacak iki Quaternion’dır. t, bu iki Quaternion arasında hangi oranda interpolasyon yapılacağını belirleyen bir float değerdir. 0.0f tüm interpolasyonu a değerinde gerçekleştirirken, 1.0f tüm interpolasyonu b değerinde gerçekleştirir.
Aşağıdaki örnek, bir topu başlangıç noktasından hedefe doğru doğrusal bir şekilde hareket ettirir:
public class BallController : MonoBehaviour
{
public Transform target;
public float speed = 1.0f;
private void Update()
{
Quaternion targetRotation = Quaternion.LookRotation(target.position - transform.position);
transform.rotation = Quaternion.Lerp(transform.rotation, targetRotation, Time.deltaTime * speed);
}
} Bu kodda, topun rotasyonu her güncellendiğinde, hedef noktasına doğru döndürülür. Quaternion.LookRotation, topun yönünü belirlemek için kullanılırken, Quaternion.Lerp, topun doğru yönde doğrusal bir şekilde hareket etmesini sağlamak için kullanılır.
LookRotation Metodu
Unity Quaternion sınıfı LookRotation metodu, bir dönüşün hedef rotasyonuna dönüştürülmesine yardımcı olan bir yöntemdir. Bu metot, iki farklı yönü alır: birincisi, rotasyonun yönü ve ikincisi, yukarı doğru vektördür. Bu yöntem, yönünüzün nereye bakması gerektiğini belirlemek için kullanışlıdır.
Metot, birinci parametre olarak hedef rotasyonu, ikinci parametre olarak da yukarı doğru vektörü alır ve sonuç olarak bir dönüş matrisi oluşturur. Eğer yukarı doğru vektör verilmezse, yöntem, hedef rotasyonuna paralel olan bir yukarı doğru vektör oluşturur.
Aşağıda, bir örnek verilerek metodu daha iyi anlayabilirsiniz:
// Önceden belirlenmiş bir hedef rotasyon ve yukarı doğru vektörü Quaternion hedefRotasyon = Quaternion.Euler(0, 90, 0); Vector3 yukariVektor = Vector3.up; // LookRotation metodu kullanarak dönüş matrisi oluşturma Quaternion donusMatrisi = Quaternion.LookRotation(hedefRotasyon * Vector3.forward, yukariVektor); // Oluşturulan dönüş matrisi kullanılarak dönüş gerçekleştirme transform.rotation = Quaternion.Lerp(transform.rotation, donusMatrisi, Time.deltaTime);
Bu örnekte, önceden belirlenmiş bir hedef rotasyon ve yukarı doğru vektör kullanarak LookRotation metodu ile bir dönüş matrisi oluşturuluyor. Daha sonra, bu dönüş matrisi, Lerp metodu kullanılarak objenin mevcut rotasyonu ile karıştırılarak bir dönüş gerçekleştiriliyor. Bu sayede, objenin yavaşça hedef rotasyona dönmesi sağlanıyor.
Normalize Metodu
Unity’deki Quaternion sınıfı, 4 elemanlı bir doğrusal cebir matrisidir ve döndürme işlemleri için kullanılır. Normalize metodu, Quaternion’u normalleştirir ve birim Quaternion elde etmemizi sağlar. Normalleştirme işlemi, Quaternion’u orijin ile birleştirdiğimizde oluşan doğru üzerindeki bir noktaya taşır ve uzunluğunu 1 olarak ayarlar.
Metodun imzası şu şekildedir:
public void Normalize();
Quaternion.Normalize() metoduna herhangi bir parametre verilmez. Quaternion kendisi üzerinde işlem yapılır ve orijin noktasına taşınarak normalleştirilir.
Örnek olarak, bir topu yavaşça döndüren bir oyunu ele alalım. Döndürme işlemi için kullanılacak Quaternion, topun dönme açısını tutar. Ancak açı değeri sık sık değişir ve Quaternion’un boyutu değişebilir. Bu yüzden Quaternion.Normalize() metodu, Quaternion’un boyutunu sabit tutmak ve doğru bir dönme işlemi gerçekleştirmek için kullanılabilir.
using UnityEngine;
public class BallController : MonoBehaviour
{
private float rotateSpeed = 50f;
private Quaternion initialRotation;
private void Start()
{
initialRotation = transform.rotation;
}
private void Update()
{
// Quaternion döndürme açısını hesapla
float rotationAngle = rotateSpeed * Time.deltaTime;
Quaternion rotation = Quaternion.Euler(0f, rotationAngle, 0f);
// Topu döndür
transform.rotation = initialRotation * rotation;
// Quaternion'u normalleştir
transform.rotation.Normalize();
}
} Bu örnekte, Update() fonksiyonu her karede çalışır ve topu yavaşça döndürür. Döndürme açısı hesaplanır ve Quaternion.Euler() metodu kullanılarak Quaternion’a dönüştürülür. Daha sonra, top döndürülür ve son olarak Quaternion.Normalize() metodu kullanılarak Quaternion normalleştirilir. Böylece, topu sabit bir şekilde döndürmek için kullanılacak doğru Quaternion boyutunu sabit tutulur.
Slerp Metodu
Unity’deki Quaternion sınıfının Slerp() yöntemi, iki döndürme arasında bir çizgi oluşturarak bir döndürmeyi diğerine doğru yumuşak bir şekilde döndürür. Bu yöntem, daha gerçekçi animasyonlar ve döndürmeler oluşturmak için kullanılır.
Slerp yöntemi, üç argüman alır: başlangıç döndürmesi, hedef döndürmesi ve bir t değeri. Bu t değeri, döndürmenin ne kadar yakın olduğunu belirler. t = 0 ise, başlangıç döndürmesi verilir. t = 1 ise, hedef döndürmesi verilir. t = 0 ile 1 arasında bir değer, bu iki döndürme arasındaki ara noktayı belirler.
Örnek olarak, bir topun hız vektörünün yönünü takip eden bir kamera düşünelim. Kamera, topun hareketini takip etmek için topun pozisyonuna doğru dönmelidir. Bu döndürme, kameranın yukarı vektörü ile topun hız vektörü arasındaki açıya eşit olmalıdır. Bu döndürme, başlangıç döndürmesi olarak belirlenebilir ve Slerp() yöntemi kullanılarak her karede hedef döndürmeye yaklaşabilir:
public class FollowBall : MonoBehaviour {
public Transform ball;
public float speed = 5.0f;
private Quaternion startRotation;
private Quaternion targetRotation;
void Start() {
startRotation = transform.rotation;
}
void Update() {
Vector3 direction = ball.position - transform.position;
targetRotation = Quaternion.LookRotation(direction, Vector3.up);
transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, speed * Time.deltaTime);
}
} Bu örnekte, kamera topu takip etmek için güncellendiğinde LookRotation() yöntemi kullanılarak hedef döndürme hesaplanır. Daha sonra, Slerp() yöntemi kullanılarak kameranın döndürmesi yumuşak bir şekilde hedef döndürmeye doğru hareket ettirilir. Bu, daha akıcı ve doğal bir kamera hareketi sağlar.
Kaynak:
https://docs.unity3d.com/2023.2/Documentation/ScriptReference/Quaternion.html