Birlikte öğreniyoruz...

Vector3 Unity oyun motorunun çekirdek altyapısında yer alan sınıflardan biridir. x,y ve z eksenlerini Float değer olarak alan ve 3D objelerin konumlandırma, yön değiştirme ya da fizik işlemleri gibi birçok çalışmada kullanılmaktadır.

Benzer olarak Vector2 ve Vector4 isimde sınıfları bulunmaktadır. Sınıfların görevleri aynı olmasına rağmen Vector2 sınıfı iki boyutlu objeler için ve Vector4 ise üç boyut artı gölgelendirme yapısı için kullanılmaktadır.

Çalışmalar sırasında Vector3Int isminde bir sınıf daha göreceksiniz. Vector3, Float değerler alırken Vector3Int ise isminden de anlaşılacağı üzere Integer değerler almaktadır. Fakat bir objeyi konumlandırırken çok ince hesaplar yapılması gerektiği için genellikle Vector3 kullanılmaktadır.

Daha önceki Unity Objeler dersimizde Transform Bileşeni üzerine kısaca değinmiştik. Fakat Unity’de Vector3 sınıfını iyi anlayabilmemiz için Transform sınıfının fonksiyonlarından “Translate” fonksiyonunu öğrenmemiz gerekiyor. Bunun için az biraz konudan saparak “Translate” fonksiyonuna değineceğiz. Ama merak etmeyin bir sonraki dersimiz sadece Transform üzerine olacak.

Bundan önceki derslerimizde metodlara JavaScript alışkanlığından dolayı fonksiyon olarak bahsediyordum. Her ikisi de aynı anlama gelse de elimiz alıştırmak için bundan sonra metod olarak bahsedeceğim.

Translate Fonksiyonu

Hatırladığınız gibi bir objenin transform bileşeninin olması gerekiyordu ve silinemiyordu. Yani mantık olarak düşünürseniz sahnede yer alan her objenin bir yeri, boyut olması gerekiyor.

Translate fonksiyonu ise Transform bileşenin Position(x,y,z pozisyon bilgileri) değerlerine müdahale ederek çeşitli işlemler yapmamızı sağlayan bir fonksiyondur.

Yazım şekli ise en basit haliyle transform.Translate(new Vector3(1f, 0f, 0f)); şeklindedir. Şöyle okuyabilirsiniz. Transform bileşeninde translate fonksiyonunu çağır ve fonksiyona oluşturduğum Vector3 sınıfını gönder.

new Vector3(1f, 0f, 0f) şeklinde yazdığımız kısımda Float olarak belirtilen değerler sırasıyla X,Y ve Z eksenlerinin bilgileridir. Eğer verilen değer 0 ise pozisyonunu korur. Örneğin burada X eksenine 1f diyerek sağa doğru 1 Float değerinde hareket et demiş oluyoruz.

Biraz daha detaya girerek transform.Translate(new Vector3(1f, 0f, 1f) * Time.deltaTime); şeklinde de bir yazımı bulunmaktadır ve genelde bu yapıyı kullanacağız. Burada yer alan Time.deltaTime kısmına ileride detaylıca değineceğiz ama şimdilik her bir saniyede işlem yap demiş olduğumuzu bilmeniz yeterli.

Şimdi yapacağımız örnekler için kendimize aşağıdaki bir yapı oluşturalım. Sahnemize üç adet 3D “Cube” objesi ve zemin için bir “Plane” objesi ekledik. Objelerin isimlerini daha kolay anlaşılması için “Dusman1, Dusman2 ve Karakter” olarak değiştirdik.

Unity Sahne Tasarımı

Sonrasında ise “Vector3Dersleri” isminde bir C# Script dosyası oluşturarak “Dusman1” objesine atamasını gerçekleştiriyoruz. Artık asıl konumuz olan Vector3 sınıfını yapılarına göre ayırarak detaylıca incelemeye başlayalım.

Vector3 Sınıfı Statik Değişkenler

Vector3 sınıfının Unity çekirdek yapısıyla birlikte geldiğini söylemiştim. Tabi bu sınıfla birlikte işlerimiz kolaylaştırması için hazır olarak gelen bir çok özellikte bulunuyor.

Vector3.left ve Vector3.right Değişkeni

Unity oyun motorunda varsayılan olarak tanımlı gelen Vector3 sınıfının “left” ve “right” özelliği, objeyi X ekseninde pozitif ve negatif alana doğru hareket ettirir.

Aslında arka planda “left” için Vector3(-1, 0, 0) ve “right” için Vector3(1, 0, 0) çalışmaktadır.

Eğer “Update” fonksiyonuna içerisinde aşağıdaki gibi Vector3.down kodu ekleyip, oyunu çalıştırsanız “Dusman1” objesinin Y ekseninde negatif yönde hareket ettiğini görebilirsiniz. Vector3.up eklerseniz ise tam tersi şekilde pozitif yönde hareket edecektir.

public class Vector3Dersleri : MonoBehaviour
{
    void Update()
    {
        transform.Translate(Vector3.left * Time.deltaTime);
    }
}

Vector3.down ve Vector3.up Değişkeni

Unity oyun motorunda varsayılan olarak tanımlı gelen Vector3 sınıfının “down” ve “up” özelliği, objeyi Y ekseninde pozitif ve negatif alana doğru hareket ettirir.

Aslında arka planda “down” için Vector3(0, -1, 0) ve “up” için Vector3(0, 1, 0) çalışmaktadır.

Eğer “Update” fonksiyonuna içerisinde aşağıdaki gibi Vector3.left kodu ekleyip, oyunu çalıştırsanız “Dusman1” objesinin X ekseninde negatif yönde hareket ettiğini görebilirsiniz. Vector3.right eklerseniz ise tam tersi şekilde pozitif yönde hareket edecektir.

public class Vector3Dersleri : MonoBehaviour
{
    void Update()
    {
        transform.Translate(Vector3.down * Time.deltaTime);
    }
}

Vector3.back ve Vector3.forward Değişkeni

Unity oyun motorunda varsayılan olarak tanımlı gelen Vector3 sınıfının “back” ve “forward” özelliği, objeyi Z ekseninde pozitif ve negatif alana doğru hareket ettirir.

Aslında arka planda “back” için Vector3(0, 0, -1) ve “forward” için Vector3(0, 0, -1) çalışmaktadır.

Eğer “Update” fonksiyonuna içerisinde aşağıdaki gibi Vector3.back kodu ekleyip, oyunu çalıştırsanız “Dusman1” objesinin Z ekseninde negatif yönde hareket ettiğini görebilirsiniz. Vector3.forward eklerseniz ise tam tersi şekilde pozitif yönde hareket edecektir.

public class Vector3Dersleri : MonoBehaviour
{
    void Update()
    {
        transform.Translate(Vector3.back * Time.deltaTime);
    }
}

Vector3.one ve Vector3.zero Değişkeni

Unity’nin Vector3 sınıfının hazır özelliklerinden olan “one” ve “zero” için hazır tanımlı koordinat bilgilerini girer.

Koordinat bilgilerini “one” statik özelliği kullanıldığında Vector3(1, 1, 1) olarak ve zero kullanıldığında ise Vector3(0, 0, 0) olarak değiştirir.

Aşağıdaki örnekteki gibi “Update” fonksiyonunda Vector3.one kullanırsanız objenin X,Y ve Z eksenlerinde aynı anda sürekli olarak bir frame kaydığını görebilirsiniz.

public class Vector3Dersleri : MonoBehaviour
{
    void Update()
    {
        transform.Translate(Vector3.one * Time.deltaTime);
    }
}

Vector3 Sınıfı Erişilebilir Değişkenler

Her bir Vector3 sınıfından oluşturulan değişken için farklı olan özellikler.

magnitude Özelliği

magnitude sayesinde bir objenin uzunluğunu hesaplayabiliriz. Vector3 sınıfının özelliklerinden olan bu yapı arka panda (x*x+y*y+z*z) hesaplaması yapmaktadır. Geri dönüş olarak Float değer döndürmektedir.

Örneğin aşağıdaki kod içerisinde, mevcut objemizin position bilgilerini Vector3 vektor = transform.position; yazarak bir vektöre aktardık. Sonrasında ise uzunluk hesaplaması için float uzunluk = vektor.magnitude; satırını kullandık.

public class Vector3Dersleri : MonoBehaviour
{
    private void Start()
    {
        Vector3 vektor = transform.position;
        float uzunluk = vektor.magnitude;
        Debug.Log(uzunluk);
    }
}

Unity resmi sitesinde eğer iki farklı objenin uzunlukları karşılaştırılacaksa sqrMagnitude kullanılarak daha performanslı sonuç elde edebileceğimiz yazmaktadır.

sqrMagnitude Özelliği

magnitude fonksiyonu gibi uzunluk hesaplamasını aktarır ama uzunluğun karesini alarak bir Float değer geri dönüş yapar. magnitude fonksiyonuna göre daha performanslı çalışmaktadır.

Aşağıdaki örnek kod yapısında iki adet yeni “Vector3” sınıfından nesne olurduk ve “sqrMagnitude” ile uzunlukları hesaplayarak if döngüsüne soktuk.

public class Vector3Dersleri : MonoBehaviour
{
    private void Start()
    {
        Vector3 birinciVektor = new Vector3(1f, 2f, 5f);
        Vector3 ikinciVektor = new Vector3(1f, 1f, 2f);

        if (birinciVektor.sqrMagnitude > ikinciVektor.sqrMagnitude)
            Debug.Log("Birinci Vektör Daha Büyük");
        else
            Debug.Log("İkinci Vektör Daha Küçük");

    }
}

Sonuç: Birinci Vektör Daha Büyük

normalized Özelliği

normalized bir objenin pozisyon bilgilerini 1 uzunluğunda döndürür. X,Y ve Z koordinatlarıma yazılan değer kaç olursa olsun -1 ve 1 arasında bir sayı dönüşü yapar.

public class Vector3Dersleri : MonoBehaviour
{
    private void Start()
    {
        Vector3 vektor = new Vector3(-0.9f, 0.5f, -3.13f);
        Debug.Log(vektor.normalized);
    }
}

Sonuç: (-0.3, 0.2, -0.9)

Public Metodlar

Vector3 sınıfının da yer alan üç farklı metod bulunmaktadır. Basit örnekler vererek bu metodları biraz inceleyelim.

Vector3.Set Metodu

Set metoduyla C# Script üzerinden X,Y,Z eksenleri için yeni pozisyonlar belirleyebiliriz.

Örneğin aşağıdaki kodda yeni bir Vector3 türünde yeni bir nesne oluşturduk ve vektorum.Set(0.1f, 1f, -0.5f); komutuyla yeni X,Y,Z pozisyonları tanımladık. Daha sonra ise transform.position = vektorum; ile bağlı olduğumuz objeye erişerek pozisyon değerlerini kendi oluşturduğumuz Vector3 nesnesi ile değiştirdik.

public class Vector3Dersleri : MonoBehaviour
{
    Vector3 vektorum;
    private void Start()
    {
        vektorum.Set(0.1f, 1f, -0.5f);
        transform.position = vektorum;
        Debug.Log(transform.position);
    }
}

Vector3.ToString Metodu

“ToString” metoduyla Vector3 sınıfında üretilmiş bir nesnenin pozisyon bilgilerini “String” türüne çevirebilirsiniz. Bu şekilde objenin pozisyon bilgilerini bir yere yazmak ya da farklı bir işlemde kullanmak için dönüştürebilirsiniz.

Aşağıdaki örnekte Vector3 türünde bir nesne oluşturarak pozisyon bilgilerini alarak ekrana yazdırdık.

public class Vector3Dersleri : MonoBehaviour
{  
    private void Start()
    {
        Vector3 vektorum = new Vector3(0.1f, 1f, -0.2f);
        Debug.Log(vektorum.ToString());
    }
}

Örneklerimizi kod üzerinde veriyorum ama mantığın kafanızda oturduğu düşünüyorum. Tabi ki bu işlemi aşağıdaki gibi oyununuzun sahnesinde yer alan bir obje için de gerçekleştirebilirsiniz. transform.position diyerek C# Script dosyasının bağlı olduğu objenin pozisyon bilgisine erişebiliriz.

public class Vector3Dersleri : MonoBehaviour
{  
    private void Start()
    {
        Debug.Log(transform.position.ToString());
    }
}

Vector3.Equals Metodu

“Equals” metodu ile iki farklı objenin pozisyon bilgilerinin aynı olup olmadığını kıyaslayabilirsiniz.

Aşağıdaki örnekte iki farklı “Vector3” sınıfından türetilmiş nesne oluşturduk ve if döngüsü içine birinciVektorum.Equals(ikinciVektorum) yazarak iki nesnenin pozisyonlarının aynı olup olmadığını karşılaştırdık.

public class Vector3Dersleri : MonoBehaviour
{  
    private void Start()
    {
        Vector3 birinciVektorum = new Vector3(1f, 0.5f, -1f);
        Vector3 ikinciVektorum = new Vector3(1f, 0.5f, -1f);

        if (birinciVektorum.Equals(ikinciVektorum))
            Debug.Log("Vektör Pozisyonları Eşit");
        else
            Debug.Log("Vektör Pozisyonları Eşit Değil");     
    }
}

Fakat Unity resmi sitesinde “Equals” metodunun her zaman doğru sonuç veremeyeceğini ve “==” kullanmanın daha sağlıklı olacağını belirtmişler. Yani örneği aşağıdaki gibi kullanabilirsiniz.

Bu tarz durumlar bana tuhaf geliyor. Böyle bir özelliğiniz var ama bazen çalışmıyor:)

public class Vector3Dersleri : MonoBehaviour
{  
    private void Start()
    {
        Vector3 birinciVektorum = new Vector3(1f, 0.5f, -1f);
        Vector3 ikinciVektorum = new Vector3(1f, 0.5f, -1f);

        if (birinciVektorum == ikinciVektorum)
            Debug.Log("Vektör Pozisyonları Eşit");
        else
            Debug.Log("Vektör Pozisyonları Eşit Değil");

    }
}

Sonuç: Vektör Pozisyonları Eşit

Statik Metodlar

Statik metodlar için kaba bir tabirle sınıftan nesne oluşturmadan kullanabileceğimiz ve Unity tarafından “Vector3” sınıfı için çekirdek yapıyla gelen yapılardır diyebiliriz.

En çok kullanacağımız metodları bu derste değineceğim ama ileri ki derslerde işlediğimiz konumuza göre yeni metodlar gördükçe eklemesini gerçekleştireceğim.

Vector3.Angle Metodu

Oyunumuzun sahnesinde yer alan iki obje arasındaki açıyı “Float” türünde geri döndürmektedir. 0 ile 180 arasında açısal oran döndürmektedir.

Vector3.Angle Metodu Sahne Tasarımı

Şimdi sahnemize yukarıdaki gibi “Dusman” ve “Karakter” isminde iki adet obje oluşturalım. Sonrasında yeni bir C# Script dosyası oluşturarak “Karakter” objemize atayalım ve aşağıdaki kodları yazalım.

public class Vector3Dersleri : MonoBehaviour
{
    public Transform dusmanTransformu;
    private void Start()
    {
        Vector3 mesafe = dusmanTransformu.position - transform.position;
        float acisalOran = Vector3.Angle(mesafe, transform.forward);
        Debug.Log(acisalOran);
    }
}

Kodumuzda public Transform dusmanTransformu; yazarak Transform türünde “public” erişim belirleyicisine sahip bir değişken oluşturduk. Sonrasında Unity oyun motoru üzerinden “Karakter” objemize “Dusman” objemizi atadır.

Bir objeye dışarıdan obje atama işlemini önceki derslerimizde görmüştük. Tekrar etmek için dışarıdan obje atama konumuza göz atabilirsiniz.

Dışarıdan obje atama

İlk başta Vector3 mesafe = dusmanTransformu.position - transform.position; yazarak iki objenin pozisyon bilgilerinin arasındaki farkı alıyoruz ve “Vector3” türünde bir değişkene atıyoruz. Objeler arasındaki farklı bulduktan sonra Vector3.Angle(mesafe, transform.forward); yazarak “Angle” metoduna, bulduğumuz mesafe bilgisi ve transform.forward bilgisini gönderiyoruz.

Burada geçen transform.forward kısmını bu dersin başlarında statik değişkenler kısmında kullanmıştık. “Angle” metodunda ikinci paremetre olarak “transform.right” kullandık. Burada “transform.right” yerine “transform.forward” ve “transform.up” kullanabilirsiniz.

Aslında bizim için önemli bir konu olduğu için şöyle bir örnek vereceğim. Oyununuzda karakterinize belirli bir açıdan düşman yaklaştığı zaman bir işlem gerçekleştirmek istiyor olabilirsiniz. Bu tarz bir durumda “Angle” metodu ile hesaplama yaparak düşman %10 açı ile yaklaştığında uyarı ver diyebiliriz.

if (acisalOran < 10f)
{
   Debug.Log("Düşman Yaklaşıyor.");
}
“Angle” metodu biraz karışık gelebilir bu sebeple yorum yazarak soru sorarsanız öğrendiğim ve anladığım kadarıyla yardımcı olabilirim.
0
Hızlı Yorum...x

Vector3.Distance Metodu

“Distance” metodu sayesinde sahnede yer alan iki obje arasındaki vektörel olarak farkı bulabilirsiniz.

Yazım kalıbı olarak float mesafe= Vector3.Distance(birinci_obje_pozisyonu, ikinci_obje_pozisyonu); kullanılır.

“Angle” metodundaki yapı üzerinden örneğimize devam edersek, aşağıdaki örnek “Dusman” ve “Karakter” objeleri arasındaki vektörel mesafeyi bize vermektedir.

public class Vector3Dersleri : MonoBehaviour
{
    public Transform dusmanTransformu;
    float mesafe;
    private void Start()
    {
        mesafe = Vector3.Distance(dusmanTransformu.position, transform.position);
        Debug.Log("Düşman ve Karakter Arasındaki Mesafe: " + mesafe);
    }
}

“Angle” metodunda olduğu gibi “Distance” metodu içinde oyundaki objeler arasında mesafelere göre işlem yapacağımızda aktif olarak kullanacağız.

Vector3.Lerp Metodu

“Lerp” metodu ile objenizin belirleyeceğiniz başlangıç pozisyonundan bitiş pozisyonuna hareket etmesini sağlarız. Başlangıç ve bitiş noktası arasında sanal bir çizgi çizerek bu çizgiyi takip ettiğini düşünebilirsiniz.

3 adet değer alan “Lerp” metodunun için yazım kalıbı public static Vector3 Lerp(Vector3 baslangicNoktasi, Vector3 bitisNoktasi, float hiz); şeklindedir.

Daha iyi anlamamız için aşağıda bir sahne tasarımı ekliyorum. Bu sahne tasarımına göre “Karakter” isminde olan objemizi başlangıç noktasından bitiş noktasına doğru hareket ettireceğiz.

Vector3.Lerp Metodu Sahne Tasarımı

Yeni bir C# Script dosyası oluşturduktan sonra aşağıdaki kodları yazarak “Karakter” isimli objeye atamasını gerçekleştiriyoruz.

public class Vector3Dersleri : MonoBehaviour
{
    public Transform baslangicNoktasi;
    public Transform bitisNoktasi;
    private float baslangicZamani;

    private void Start()
    {
        baslangicZamani = Time.time;
    }

    private void Update()
    {
        Time.timeScale = 0.5f;
        transform.position = Vector3.Lerp(baslangicNoktasi.position, bitisNoktasi.position, (Time.time - baslangicZamani) * 0.1f);
    }
}

İlk önce public Transform baslangicNoktasi; ve public Transform bitisNoktasi; isminde ve “Transform” türünde iki adet değişken oluşturduk. Oluşturduğumuz değişkenler Unity üzerinde “Karakter” objesinin içerisinde gözükecektir. Burada dışarıdan obje atama işlemini gerçekleştiriyoruz.

private float baslangicZamani; isminde bir float değişken oluşturduk. Bu değişkeni “Start()” metodunun içerisine baslangicZamani = Time.time; koyarak oyun başladığında başlangıç süresini belirtmesi için yaptık. “Time.time” ve “Time.timeScale” komutlarına birazdan değineceğim.

Son olarak transform.position = Vector3.Lerp(baslangicNoktasi.position, bitisNoktasi.position, (Time.time - baslangicZamani) * 0.1f); satısında ise yaptığımız iş aslında şu şekilde.

Script dosyasının içinde bulunduğu objenin pozisyonunu değiştireceğimiz için transform.position olarak belirttik. Vector3.Lerp yazarak kahramanımız metodun ismini yazdık ve içerisine baslangicNoktasi.position, bitisNoktasi.position, parametrelerini yazarak objenin nereden nereye hareket edeceğini belirttik. Son parametre olarak ise (Time.time - baslangicZamani) * 0.1f) yazdık. Burada oyunun o anki süresinden başlangıç zamanını çıkartarak ne kadar hızlı hareket etmesini istediğimizi belirtmiş olduk.

Şimdi bahsedeceğimi söylediğim “Time.time“, “Time.timeScale” ve diğer en çok kullanacağımız “Time.deltaTime” metodlarını inceleyelim.

Time.time : “Time.time” ile oyun başladıktan sonra geçen toplam süreyi otomatik olarak bize döner.

Time.timeScale: “Time.timeScale” içi ise oyunun hızı diye düşünebilirsiniz. 0 ile 1 sayıları arasında Float değer almaktadır. “0f” yazdığınızda oyun duracak ve “1f” yazdığınızda ise normal hızında başlayacaktır. Örneğin “0.5f” yazarsanız normal hızının yarısında çalışacaktır. Oyunlarda bulunan durdurma ve başlatma yapısı bu şekilde çalışmaktadır.

Time.deltaTime: İleride çokça kullanacağımız kritik bir özellik aslında. Mantığı ise her bir karenin başlangıcından bitişine kadar olan süreyi belirtmektedir. Daha önceden bahsettiğim gibi “Update()” metodu her bir karede bir kere çalışır. Örneğin 35. kareden – 36. kareye geçerken ki süreyi bize bildirir. Eğer biz bu değişkene manuel olarak bir değer atarsak ve oyunu oynayan kişinin sistem performansına göre oyun ya yavaşlayacak ya da çok hızlı hareket edecektir. Merak etmeyin ileride bu konuya detaylı değineceğiz.

Vector3.Max Metodu

“Max” metodu ile iki objenin X,Y ve Z pozisyon değerlerini karşılaştırarak en yüksek olanları bize geri döner.

Örneğin aşağıdaki gibi iki adet Vector3 türünde değişkenin pozisyon bilgilerini Vector3.Max(birinciVektor, ikiciVektor) yazım kalıbı ile karşılaştırabiliriz.

public class Vector3Dersleri : MonoBehaviour
{
    private void Start()
    {
        Vector3 birinciVektor = new Vector3(1f, 3f, 6f);
        Vector3 ikiciVektor = new Vector3(2f, 5f, 3f);

        Debug.Log(Vector3.Max(birinciVektor, ikiciVektor));
    }
}

Sonuç: (2.0, 5.0, 6.0)

Vector3.Min Metodu

Tıpkı “Max” metodu gibi iki farklı objenin pozisyon değerlerini karşılaştır. Fakat “Max” metodunun tersi şekilde “Min” metodu en küçük olan posizyon değerlerini verecektir.

Örneğin aşağıdaki gibi iki adet Vector3 türünde değişkenin pozisyon bilgilerini Vector3.Min(birinciVektor, ikiciVektor) yazım kalıbı ile karşılaştırabiliriz.

public class Vector3Dersleri : MonoBehaviour
{
    private void Start()
    {
        Vector3 birinciVektor = new Vector3(1f, 3f, 6f);
        Vector3 ikiciVektor = new Vector3(2f, 5f, 3f);

        Debug.Log(Vector3.Min(birinciVektor, ikiciVektor));
    }
}

Sonuç: (1.0, 3.0, 3.0)

Vector3.Scale Metodu

“Scale” metodu ile iki farklı objenin X,Y ve Z pozisyon değerlerini her koordinat için ayrı ayrı çarparak farklı bir “Vector” değer olarak dönüş yapar.

Örneğin aşağıdaki gibi iki adet Vector3 türünde değişkenin pozisyon bilgilerini Vector3.Scale(birinciVektor, ikiciVektor) yazım kalıbı ile çarpımını alabilirsiniz.

public class Vector3Dersleri : MonoBehaviour
{
    private void Start()
    {
        Vector3 birinciVektor = new Vector3(1f, 3f, 6f);
        Vector3 ikiciVektor = new Vector3(2f, 5f, 3f);

        Debug.Log(Vector3.Scale(birinciVektor, ikiciVektor));
    }
}

Sonuç: (2.0, 15.0, 18.0)

Operator İşlemleri

Vektörler içerisinde karşılaştırma matematiksel operatörleri kullanma imkanımız bulunmaktadır.

Bir vektör pozisyon bilgisini farklı bir vektörün pozisyon bilgisi ile toplama ve çıkarma yapabiliriz. Fakat çarpma ve bölme için aşağıdaki örnekteki gibi sadece Float değer kullanabilirsiniz.

public class Vector3Dersleri : MonoBehaviour
{
    private void Start()
    {
        Vector3 birinciVektor = new Vector3(2f, 4f, 3f);
        Vector3 ikiciVektor = new Vector3(1f, 2f, 1f);

        Debug.Log(birinciVektor + ikiciVektor); // Sonuç: (3.0, 6.0, 4.0)
        Debug.Log(birinciVektor - ikiciVektor); // Sonuç: (1.0, 2.0, 2.0)
        Debug.Log(birinciVektor * 2f); // Sonuç: (4.0, 8.0, 6.0)
        Debug.Log(birinciVektor / 2f); // Sonuç: (1.0, 2.0, 1.5)
    }
 }

Ayrıca karşılaştırma operatörlerinden eşittir(==) ya da eşit değildir(!=) operatörlerini vektörleri karşılaştırmak için kullanabilirsiniz.

public class Vector3Dersleri : MonoBehaviour
{
    private void Start()
    {
        Vector3 birinciVektor = new Vector3(1f, 2f, 1f);
        Vector3 ikiciVektor = new Vector3(1f, 2f, 1f);

        if (birinciVektor == ikiciVektor)
            Debug.Log("Vektörler birbirine eşit gözüküyor.");
        
    }
}

Vector3 sınıfında öğrendiklerimizi pekiştireceğimiz yeni dersimiz Transform ve Quaternion sınıfının özelliklerinin ve metodlarının kullanımı dersine aşağıdaki linkten ulaşabilirsiniz.