Unity Transform Nedir?

Merhaba dostlar, bu yazımızda Unity Transform Nedir? sorusunu cevaplayacağız. Unity programı içerisinde Transform, içerisinde konum, rotasyon (kullandığı açı) ve boyut değerlerini bulunduran ve bu değerleri çeşitli şekillerde kontrol etmemizi sağlayan fonksiyonları bize sunan bir bileşendir. Bilmeniz gerekir ki, bir sahnede kullanacağımız her oyun objesi (GameObject) Transform bileşenine sahip olmak zorundadır. Bu bileşen olmadan, obje bir konuma sahip olamaz, haliyle sahne içerisinde varolamaz. GameObject hakkında daha fazla bilgi almak isterseniz, Unity GameObject Nedir? yazımıza göz atabilirsiniz.

Belirttiğimiz bu değerleri ister kod üzerinden, istersek de Unity arayüzü üzerinden ayarlamamız mümkün. Bu bilgiyi düşündüğümüzde, bileşenin aslında hem sahne tasarımlarımızda hem de oyun içerisinde kullandığımız bir bileşen olduğunu söyleyebiliriz. Kod ile bu değişkenleri değiştirmenin nasıl yapıldığını yazının devamında bulabilirsiniz. Editor üzerinde yapmanız gereken tek şey ise gerekli alanlardaki verileri elle yazarak değiştirmek ya da Transform aracını kullanarak sürükleyerek objenin değerlerini değiştirmek. Daha önceleri editor üzerinde kullanabileceğimiz araçlar konum, rotasyon ve açı için ayrı ayrıydı. Ancak Unity 2019 sürümünde gelen yeni bir araç bu değişkenleri bünyesinde tutuyor ve bu sayede araçlar arasında geçiş yapmadan istediğimiz özelliği değiştirebiliyoruz.

Konum, rotasyon ve boyut değişkenleri dışında, Transfrom bileşeni içerisinde bir ebeveyn-çocuk sistemi bulunur. Bu sistem sayesinde objeleri birbirinin alt objesi haline getirebilir ve beraber hareket etmelerini sağlayabiliriz. Ayrıca bu yapı sayesinde sahnemizi, hiyerarşi panelimizi daha derli toplu halde tutup, geliştirme aşamasında daha rahat şekilde çalışabiliriz. Basit bir örnek düşünürsek, çevre isimli bir, bunun alt objeleri olarak, binalar ve araçlar, ve bunların altında da direkt kullanacağımız objeleri alt obje olarak belirtmek işimizi baya kolaylaştıracaktır. Örnek resimde hiyerarşi panelinde gruplandırma yapılmamış ve gruplandırılmış hallerini görebilirsiniz.

Unity – Transform İle Kullanılabilecek Kodlar

Unity – Transform ile kullanılabilecek kodlar konusunda alt başlıklara geçmeden önce, genel kullanıma sahip, yazının devamındanki başlıklar altına yerleştirilemeyecek birkaç koddan bahsetmek istiyorum. Bu kodlar aynı zamanda gameObject gibi sınıflarda da kullanılabilir ancak burada yer vermenin daha uygun olduğunu düşünüyorum.

gameObject : Transform bileşeninin ait olduğu nesnenin kendisine erişmemizi sağlar.

tag : Oyun objesine atamış olduğumuz etiket değerini elde etmemizi sağlar. Ayrıca bu değişkene erişip değiştirebiliriz.

//Log ekranına objenin tagını yazdırır.
Debug.Log(transform.tag);

name : Oyun objesinin ismine erişmemizi ve değiştirebilmemizi sağlar. Aynı name değişkeni gibi tag değişkeni de her oyun objesinde bulunan özelliklerdendir. Objeler hakkında daha fazla bilgi edinmek isterseniz “Unity – GameObject Nedir ?” adlı yazımızı okumanızı öneririz.

//Log ekranına objenin adını yazdırır.
Debug.Log(transform.name); 

Özellikler – Erişilebilir Değişkenler

Şimdi gelelim Transform bileşenin sahip olduğu değişkenlere erişmek için kullanabildiğimiz kodlar konusuna. Bu değişkenler sayesinde konum, rotasyon, boyut özellikleri dışında, şayet varsa objenin ebeveyn objesine, alt objelerine de erişebiliriz.

childCount : Objenin sahip olduğu altobje sayısını elde etmemizi sağlar. Dikkat etmeniz gereken şey, bütün altobje sayısını değil, yalnızca bir alt seviyedeki objeleri alır. Aile olarak düşünürsek, bireyin yalnızca çocuk sayısını alırız, torunları bu hesaba dahil olmaz.

    //başlangıçta objenin adını ve sahip olduğu alt obje sayısını log ekranına yazdırır
    void Start () {
        Debug.Log (transform.name + " adlı obje" + transform.childCount + " adet alt objeye sahip");
    }

eulerAngles : Objenin rotasyon değerini elde etmemizi sağlar. İstersek bu değeri kod ile değiştirebiliriz. Ancak dikkat etmek gereken bir konu var ki, eulerAngles Vector3 cinsinden verileri gösterse de, arkaplanda rotasyon için veriler Quaternion formatında tutulur. eulerAngles ile aldığımız değer de arkaplanda Quaternion değişkeninden Vector3 değişkenine dönüştürülerek bize döndürülür. Önemli bir hatırlatma, eulerAngles değerini kullanırken eksen değerlerini tek tek girmemek önerilir. Yani eulerAngles.z=1 şeklinde atamalar yapmaktan kaçının.

    //aşağıdaki örnek ile obje x,y,z eksenlerinde tuşlara basılınca
    // basılan eksende dönüşe başlayacak veya duracaktır.
    float donusHizi = 45;
    Vector3 varolanAci;
    float x;
    float y;
    float z;

    void Update () {
        //tuşlara basıldıkça değerler 0 veya 1 değerleri alacak
        //başlangıçta otomatik olarak 0 değeri alacakları için belirtilen eksende dönüş olmayacaktır
        if (Input.GetKeyDown (KeyCode.X)) x = 1 - x;
        if (Input.GetKeyDown (KeyCode.Y)) y = 1 - y;
        if (Input.GetKeyDown (KeyCode.Z)) z = 1 - z;

        //varolanAci değişkenini verilen değer, geçen zaman ve dönüş hiziyle çarpılarak değiştiriliyor.
        varolanAci += new Vector3 (x, y, z) * Time.deltaTime * donusHizi;

        //yaptığımız değişikliği eulerAngles kullanarak objeye aktarıyoruz.
        transform.eulerAngles = varolanAci;
    }

forward : Objenin z ekseninin (editorde mavi renkli ok olarak gösterilen yön) Vector3 değerini Genel (World) koordinat sistemine göre uyarlayıp normalleştirerek, 1 birim uzunluğa sahip hale getirerek bize geri döndürür.

    float donusHizi = 45f;
    void Update () {
        //space tuşuna basılı tutulduğunda z ekseninde
        //verilen donuzHizi değerine göredöndürme işlemi yapar
        if (Input.GetKey (KeyCode.Space))
            transform.eulerAngles += transform.forward * Time.deltaTime * donusHizi;

        //w tuşuna basıldığında objenin z eksenine göre 1 birim ileri ışınlar
        // objenin açısını değiştirerek deneyebilirsiniz.
        if (Input.GetKeyDown (KeyCode.W))
            transform.position += transform.forward;
    }

hasChanged : Transform değerlerine bir atama işlemi yapılıp yapılmadığını kontrol etmemizi sağlar.

    //objeye yeni bir posizyon değeri atadığımızda 
    //hasChanged true değeri alır
    void Update () {
        if (transform.hasChanged) {
            Debug.Log ("Transform değeri değişti");
            transform.hasChanged = false;
        }
        if (Input.GetKeyDown (KeyCode.W)) {
            transform.position += transform.forward;
        }
    }

hierarchyCapacity : Normalde Unity, standart olarak belirli bir sayıda hiyerarşi kapasitesine sahiptir. Duruma göre gerektiğinde otomatik olarak bu sayıyı kendisi arttırır. Ancak büyük projelerde sistem kaynakları tüketimini azaltıp performansı arttırmak adına bu değer, kullanmak istediğiniz obje sayısından birazcık daha fazla olacak şekilde belirlenebilir. Int tipinde bir değişkendir.

hierarchyCount : Hiyerarşide objenin kaç adet altobjeye sahip olduğunu elde etmemizi sağlar. childCount’tan farklı olarak bütün altobjeleri alır.

    //objenin bütün altobjelerini toplam sayısını 
    //log ekranına yazdıracaktır
    void Start () {
        Debug.Log (transform.name + " adlı obje " + transform.hierarchyCount + " objeyi altında bulundurmaktadır");
    }

localEulerAngles : Objenin rotasyonun ebeveyn objesinin rotasyon değerini baz alacak şekilde Vector3 tipinde elde etmemizi sağlar. Aynı zamanda bu değişkene değer atama işlemi de gerçekleştirebiliriz. Genel koordinat sistemine göre veya kendi yapısına göre değil de, ebeveyn objesini baz alarak sağa sola döndürmek bu değişken için kullanabileceğimiz basit bir örnek olabilir. Eğer obje bir ebeveyne sahip değilse genel kooardinat sistemine göre rotasyon işlemlerini gerçekleştirir.

    float donusHizi = 45;
    //A ve D tuşlarına basıldığı sürece
    //Ebeveyne göre sağa veya sola dönüş sağlar
    void Update () {
        if (Input.GetKey (KeyCode.D))
            transform.localEulerAngles += Vector3.up * Time.deltaTime * donusHizi;
        if (Input.GetKey (KeyCode.A))
            transform.localEulerAngles += Vector3.down * Time.deltaTime * donusHizi;
    }

localPosition : Objenin ebeveyninin pozisyonunu baz olarak sahip olduğunu pozisyondur. Eğer obje bir ebeveyne sahip değilse position değişkeni ile aynı değere sahiptir.

    void Start () {
        //local ve genel pozisyonlarını log ekranına yazdırın
        //obje ve ebeveynin pozisyonlarını değiştirerek tekrar tekrar farkı gözlemleyin
        Debug.Log ("Local pozisyon:" + transform.localPosition);
        Debug.Log ("Sahne pozisyonu:" + transform.position);
    }

localRotation : Objenin rotasyon değerini ebeveyninin rotasyonunu baz alarak ve Quaternion cinsinde döndürür. Bu değere direkt atama yapmak pek önerilmez. Quaternion konusuna hakimseniz deneyebiliriz. Onun dışında yazının devamında bulabileceğini metodları kullanarak döndürme işlemi gerçekleştirebilirsiniz.

    //objenin rotasyonunu başlangıçta sıfırlar
    void Start () {
        transform.localRotation = Quaternion.identity;
    }

localScale : Objenin ebeveynini baz alarak boyutlarını tutan değişkendir. Ebeveyn boyutları da altobjeleri etkilemektedir. Bu değişkene atamalar yaparak obje boyutlarını değiştirebiliriz. Vector3 cinsinden değer alır.

    void Start () {
        //local ve genel boyutları arasındaki farkı gösterir
        //obje ve ebeveyn boyutlarıyla oynayarak aradaki farkı gözlemleyebilirsiniz
        Debug.Log ("Local pozisyon:" + transform.localScale);
        Debug.Log ("Sahne-Genel pozisyonu:" + transform.lossyScale);
    }

    void Update () {
        //space tuşuna basıldıkça her eksende boyutlarını 1 birim arttırır
        if (Input.GetKeyDown (KeyCode.Space))
            transform.localScale += Vector3.one;
    }

localToWorldMatrix : Matrix4x4 tipinde olan bir değişkendir. Objenin konum, rotasyon, boyut gibi özelliklerini tutan, local halinden Genel (World) yapısına çevirilmiş bir değer tutar. Sadece okunabilir haldedir, direkt değişken ataması yapılamaz. Matrix4x4 tipinde değişkenler daha ileri seviye yapılardır ve Unity içerisinde kodlama kısmında çok fazla kullanmamıza gerek kalmamaktadır. Bunun yerine public metodlar kısmında bahsettiğimiz TransformPoint metodunu kullanabilirsiniz.

lossyScale : Objenin genel (global) boyutlarının tutulduğu değişkendir. Değer ataması yapılamaz sadece okunabilir moddadır. Değer ataması yapmak için localScale değişkenini kullanabilirsiniz. 

parent : Objenin ebeveynine erişmemizi veya değiştirmemizi sağlayan değişkendir. 

    //editorde sürükle bırak yapabileceğimiz
    //bir obje alanı yaratır
    [SerializeField]
    GameObject yeniEbeveyn;

    void Start () {
        //eğer obje ebeveyne sahipse
        //ebevyn objenin ismini log ekranına yazdırır
        if (transform.parent != null)
            Debug.Log ("Ebeveyn objenin ismi: " + transform.parent.name);

        //Eğer yeniEbeveyn değişkeni atanmışsa, boş değilse
        //objenin ebeveynini yeniEbeveyn değişkeni olarak atar
        if (yeniEbeveyn != null) {
            transform.parent = yeniEbeveyn.transform;
            Debug.Log ("Yeni Ebeveyn objenin ismi: " + transform.parent.name);
        }
    }

position : Objenin genel koordinat sistemine göre konum değerini tutan ve değiştrmemizi sağlayan değişkendir.

    void Update () {
        //W tuşuna basıldığında -1, S tuşuna basıldığında 1 değerini ileri değişkenine atar
        //hiçbirine basılmazsa 0 değeri alır
        float ileri = Input.GetAxis ("Vertical");
        //A tuşuna basıldığında -1, D tuşuna basıldığında 1 değerini sag değişkenine atar
        //hiçbirine basılmazsa 0 değeri alır
        float sag = Input.GetAxis ("Horizontal");

        //kullanıcıdan alınan değişkenlerle bir vector3 değişkeni oluşturup
        //bu değişkeni position değişkenine ekleyerek hareket sağlanır.
        transform.position += new Vector3 (sag, 0, ileri) * Time.deltaTime;
    }

right : Objenin local sağ yönü verisini, yani local x ekseninin genel koordinat sistemine göre elde etmemizi sağlar.

    float donusHizi = 45f;
    void Update () {
        //space tuşuna basılı tutulduğunda objenin x ekseninde
        //verilen donuzHizi değerine göredöndürme işlemi yapar
        if (Input.GetKey (KeyCode.Space))
            transform.eulerAngles += transform.right * Time.deltaTime * donusHizi;

        //D tuşuna basıldığında objenin x eksenine göre 1 birim ileri ışınlar
        // objenin açısını değiştirerek deneyebilirsiniz.
        if (Input.GetKeyDown (KeyCode.D))
            transform.position += transform.right;
    }

root : En üst seviyedeki parent objesine erişmemizi sağlayan değişkendir. Eğer obje herhangi bir parent objesine sahip değilse objenin kendisini döndürecektir.

    void Start () {
        //eğer transform root ile aynı değere sahip ise
        //objenin ebeveyni yoktur
        //eğer objenin ebeveyni var ise ebeveyn ismini log ekranına yazdırırız
        if (transform == transform.root)
            Debug.Log ("Ebeveyne sahip değil");
        else {
            Debug.Log ("En üst ebeveyn ismi: " + transform.root.name);
        }
    }

rotation: Objenin genel koordinat sistemindeki rotasyon değerini Quaternion tipinde tutan değişkendir.

    //hedef objeyi sürükleyip bırakabileceğimiz bir alan oluşturuyoruz
    [SerializeField]
    Transform hedefObje;

    Quaternion baslangic;
    bool dondur = false;
    float donmeOrani = 0;

    void Update () {
        //eğer dönme işlemi yapılmıyorsa ve space tuşuna basılırsa
        //dönme oranını sıfırlatıp dönmeyi başlatıyor
        if (Input.GetKeyDown (KeyCode.Space) && !dondur) {
            dondur = true;
            donmeOrani = 0;
            baslangic = transform.rotation;
        }

        if (dondur) {
            donmeOrani += Time.deltaTime;
            //donme orani sayesinde Quaternion.Slerp fonksiyonuyla başlangıc ve hedef rotasyonlar arasında
            //belirli bir oranda değişim sağlanabiliyor
            //örneğin 0 dersek rotasyon baslangic değerini alır
            //1 dersek de hedefObje.rotation değişkenini
            transform.rotation = Quaternion.Slerp (baslangic, hedefObje.rotation, donmeOrani);
            if (donmeOrani > 1) {
                dondur = false;
            }
        }
    }

up : Objenin yukarı yönünü, yani Y eksenini genel kooardinat sistemine uyarlanmış şekilde elde etmemizi sağlar.

    float donusHizi = 45f;
    void Update () {
        //space tuşuna basılı tutulduğunda objenin Y ekseninde
        //verilen donuzHizi değerine göre döndürme işlemi yapar
        if (Input.GetKey (KeyCode.Space))
            transform.eulerAngles += transform.up * Time.deltaTime * donusHizi;

        //D tuşuna basıldığında objenin Y eksenine göre 1 birim ileri ışınlar
        // objenin açısını değiştirerek deneyebilirsiniz.
        if (Input.GetKeyDown (KeyCode.E))
            transform.position += transform.up;
    }

worldToLocalMatrix : Genel koordinat sistemindeki bir transform verisini local, obje koordinatlarına göre uyarlayan Matrix4x4 tipinde bir değer döndüren değişkendir. İleri seviye konulardır. Bunun yerine yazının devamında bahsettiğimiz InverseTransformPoint komutunu kullanabilirsiniz.

Public Metodlar

DetachChildren : Objenin bütün altobjelerini ondan ayırır, altobje olmaktan çıkarır. Altobjeler de altobjelere sahipse bunların ebeveyn-çocuk yapısı bozulmaz. Objenin silip altobjelerini korumak istediğiniz ve benzeri durumlarda kullanabileceğiniz bir fonksiyondur.

    //Space tuşuna basıldığında altobjeleri bu objeden ayırır
    //ardından objenin kendisini yok eder
    void Update () {
        if (Input.GetKeyDown (KeyCode.Space)) {
            transform.DetachChildren ();
            Destroy (gameObject);
        }
    }

Find : Objenin altobjelerini ismine göre arayıp bulmamızı sağlayan fonksiyondur. Eğer o isimde bir obje bulamazsa null değer döndürür. Ayrıca “/” karakteri kullanarak altobjelerin de altına inebiliriz, yani hiyerarşik aramalar da yapabiliriz.

    void Start () {
        //kapı adlı altobjeyi arar
        //bulursa log ekranına pozisyon değerini bulamazsa bulunamadı yazısını yazdırır
        Transform solKapi = transform.Find ("Sol Kapı");
        if (solKapi != null) {
            Debug.Log ("Sol Kapı pozisyonu: " + solKapi.position);
        } else {
            Debug.Log ("Sol kapı bulunamadı");
        }

        //altobje olan sağ kapı adlı objenin altında bulunan sapı isimli
        //objeyi arar.Bulup bulamadığını log ekranında yazdırır
        Transform sağKapiSapi = transform.Find ("Sağ Kapı/Sapı");
        if (sağKapiSapi == null) {
            Debug.Log ("Sağ kapı sapı bulunamadı");
        } else {
            Debug.Log ("Sağ kapı sapı bulundu");
        }
    }

GetChild : Index değerine, sırasına göre altobjelere erişmemizi sağlar. Verilecek index değeri 0’dan küçük veya childCount değerinden büyük olursa hata verecektir.

    void Start () {
        //childCount değerine bakarak, objenin altobjeye sahip olup olmadığını anlayabiliriz
        if (transform.childCount > 0) {
            //ilk ve son altobjeyi bulup ismini log ekrana yazdırır
            //index değerleri 0'dan başlar bu yüzden 0 ve childCount-1 kullanıyoruz
            //örneğin 10 adet obje varsa indexleri 0'dan başlayıp 9'da son bulacaktır.
            Debug.Log ("İlk altobjenin ismi: " + transform.GetChild (0).name);
            Debug.Log ("Son altobjenin ismi: " + transform.GetChild (transform.childCount - 1).name);
        } else {
            Debug.Log (transform.name + " hiçbir altobjeye sahip değil");
        }
    }

GetSiblingIndex : Eğer obje bir ebeveyne sahip ise, bu ebeveyn altındaki index değerini elde etmemizi sağlar.

    void Start () {
        //transform değişkenini bu şekilde foreach döngüsüne sokarak da sırayla
        //altobjelere erişebiliriz
        //örnekte her bir altobjeye erişip ismini ve index değerini log ekranına yazdırıyoruz.
        foreach (Transform altobje in transform) {
            Debug.Log (altobje.name + " index değeri : " + altobje.GetSiblingIndex ());
        }
    }

InverseTransformDirection : Genel koordinat sistemindeki bir yön/rotasyon Vector3 verisini objenin rotasyonunu baz alarak, onu 0,0,0 değeri varsayarak hesaplar ve bize geri döndürür.

    //Objenin rotasyon değerini değiştirip o şekilde denemek tam işlevini görmenizi sağlayacaktır.

    void Start () {
        //Örnekte genel kooardinat sistemindeki yukarı yön değerini
        //objenin koordinatlarına göre şekillendirip log ekranın yazdırıyoruz.
        Vector3 objeyeGoreYon;
        objeyeGoreYon = transform.InverseTransformDirection (Vector3.up);
        Debug.Log (objeyeGoreYon);
    }

InverseTransformPoint : Genel koordinat sistemine göre verilen bir pozisyon, değerini objeye göre elde etmemizi sağlar. Objeyi merkez (0,0,0) noktası kabul ederek işlem yapıp yeni bir vector3 değeri elde etmemizi sağlar diyebiliriz. Objenin konumu, rotasyonu ve boyutları bu hesaplamada etkilir.

    //Objenin pozisyon değerini merkez (0,0,0) noktasından farklı bir değer alacak
    //şekilde değiştirirseniz tam olarak işlevini anlayabilirsiniz.
    //isterseniz scale değerleriyle oynayarak da etkilerini görebilirsiniz.

    void Start () {
        //3,0,5 konumunu obje koordinatlarına göre tekrar şekillendiriyoruz
        //objenin kendisini (0,0,0) sayacağı için, eğer
        //obje sahnenin merkezinde, global 0,0,0 konumunda olursa 
        //verdiğimiz değer aynı şekilde ekrana yazdırılır
        Vector3 objeyeGoreKonum;
        objeyeGoreKonum = transform.InverseTransformPoint (new Vector3 (3, 0, 5));
        Debug.Log (objeyeGoreKonum);
    }

InverseTransformVector :Genel koordinat sistemine göre verilen Vector3 değerlerini objenin boyutu ve rotasyon değerlerine göre hesaplar ve bize geri verir.

    //farkı daha iyi görebilmek için
    //objenin scale ve rotation değerleriyle oynayıp değiştirin
    void Start () {
        //3,0,5 değerlerine sahip vektörü objenin rotasyon ve büyüklüğüne göre
        //local koordinat sistemine uyarlar
        //log ekranına genel ve local değerleri yazdırır
        Vector3 objeyeGoreKonum;
        Vector3 konum = new Vector3 (3, 0, 5);
        objeyeGoreKonum = transform.InverseTransformVector (konum);
        Debug.Log ("Genel Koordinat Sistemi => Konum :" + konum + "vektör büyüklüğü" + konum.magnitude);
        Debug.Log ("Obje Koordinat Sistemi => Konum :" + objeyeGoreKonum + "vektör büyüklüğü" + objeyeGoreKonum.magnitude);
    }

IsChildOf : Verilen Transform değişkeni objenin ebeveyni mi, yani bu obje verilen objenin altobjesi mi bunu true veya false değerleri olarak bize döndürür.

    [SerializeField]
    Transform obje;

    void Start () {
        //Bu scripte sahip objenin, verilen objenin altobjesi,çocuğu olup olmadığını log ekranına yazdırır.
        if (transform.IsChildOf (obje)) {
            Debug.Log (obje.name + "isimli obje" + transform.name + "isimli objenin ebeveyni");
        } else {
            Debug.Log (obje.name + "isimli obje" + transform.name + "isimli objenin ebeveyni değil");
        }
    }

LookAt : Objenin Vector3 cinsinden verilen konuma bakmasını, önünü ona doğru çevirmesi sağlanır.

    void Update () {
        //D tuşuna basılınca obje kendi sağ yukarısına döner
        if (Input.GetKeyDown (KeyCode.D)) {
            transform.LookAt (transform.right + transform.up);
        }
    }

Rotate : Vector3 cinsinden değerler vererek objeyi döndürmemizi, rotasyon değerini değiştirmemizi sağlar. Objeyi ister kendi (local) ekseninde istersek de genel dünya eksenlerinde döndürebiliriz.

    Vector3 xDonus = new Vector3 (15, 0, 0);

    void Update () {
        //D tuşuna basılınca objeyi
        //kendi y ekseninde 15 derece döndürür
        if (Input.GetKeyDown (KeyCode.D)) {
            transform.Rotate (0, 15, 0);
            //transform.Rotate(new Vector3(0,15,0)); şeklinde de yazılabilir
        }
        //objeyi genel x ekseninde 15 derece döndürür;
        if (Input.GetKeyDown (KeyCode.W)) {
            transform.Rotate (xDonus, Space.World);
        }
        //farklı değerler kullanarak siz de deneyin
    }

RotateAround : Objeyi belirli bir noktanın etrafında döndürmemizi sağlayan fonksiyondur. Merkez noktası dışında, dönüş işleminin ekseni ve kaç derecelik açı ile dönüş yapılacağını da belirtmemiz gerekir.

    //inspector ekranında merkez olarak kullanacağınız
    //objeyi atamayı unutmayın
    [SerializeField]
    Transform merkezObje;

    void Update () {
        //objeyi merkezObjesinin etrafında y ekseninde 30 derecelik açıyla döndürür
        transform.RotateAround (merkezObje.position, Vector3.up, 30 * Time.deltaTime);
    }

SetAsFirstSibling : Objeyi ebeveyninin ilk altobjesi haline getirir. Bu sıralama değişimi hiyerarşik olarak yapılır.

    void Start () {
        //bu scriptin altobjelerinde en son sırada bulunanını
        //ilk sıraya yerleştirir. Diğer objelere sıralamada 1 birim aşağı kayar.
        Transform sonAltobje = transform.GetChild (transform.childCount - 1);
        sonAltobje.SetAsFirstSibling ();
    }

SetAsLastSibling : Objeyi ebeveyninin hiyerarşik olarak en sonuncu altobjesi haline getirir.

void Start () {
        //bu scriptin bulunduğu objenin altobjelerinde ilk sırada olanı
        //son sıraya yerleştirir. Diğer objelere sıralamada 1 birim yukarıya doğru kayar.
        Transform sonAltobje = transform.GetChild (0);
        sonAltobje.SetAsLastSibling ();
    }

SetParent : Objeye bir ebeveyn vermemizi, haliyle verdiğimiz objenin altobjesi haline getirmemizi sağlar. Transform cinsinden bir değişken alır.

[SerializeField]
    Transform yeniEbeveyn;
    void Start () {
        //verilen yeniEbeveyn objesini ebeveyn olarak atar
        transform.SetParent (yeniEbeveyn);
    }

SetPositionAndRotation : Vector3 ve Quaternion cinsinden iki değişken alır, ve objenin konumunu ve rotasyonunu bu verilen değişkenler olarak belirler.

    //objenin belirli bir konuma ve açıya gitmesi için kullanabilirsiniz
    void Start () {
        //objenin pozisyonunu sıfırlar, rotasyonunu aynı bırakır;
        transform.SetPositionAndRotation (Vector3.zero, transform.rotation);
        //objenin pozisyonunu korurken rotasyonunu sıfırlar;
        transform.SetPositionAndRotation (transform.position, Quaternion.identity);
        //objenin pozisyonunu ve rotasyonunu sıfırlar
        transform.SetPositionAndRotation (Vector3.zero, Quaternion.identity);
    }

SetSiblingIndex : Obje bir ebeveyne sahipse, altobje olarak sırasını değiştirmemizi sağlar. Int tipinde verdiğimiz index değerine göre objenin hiyerarşik konumunu değiştirir.

    //objeyi sırasını 2.index olarak atar
    //yani 3.altobje haline gelir
    void Start () {
        transform.SetSiblingIndex (2);
    }

TransformDirection : Obje local koordinatlarında elde ettiğimiz Vector3 cinsinden olan yön verisini genel (global) koordinatlara göre elde etmemizi sağlar. Objenin rotasyon değerleri hesaplamada etkilidir.

    [SerializeField]
    GameObject yeniObje;
    void Start () {
        // objeye göre 45,0,45 vector3 değerien sahip rotasyonu
        // sahip yeni bir obje yaratır
        Vector3 yeniobjeRotasyonu = transform.TransformDirection (45, 0, 45);
        Instantiate (yeniObje, transform.position, Quaternion.Euler (yeniobjeRotasyonu));
    }

TransformPoint : Obje local değerlerine göre elde edilen Vector3 pozisyon değerini genel, global sisteme çevirmemizi sağlar. Objenin pozisyonu, rotasyonu ve boyutları hesaplamaya etki eder.

    [SerializeField]
    GameObject yeniObje;
    void Start () {
        // objenin 3 birim yukarısında yeni bir obje yaratır
        Vector3 yeniObjePozisyonu = transform.TransformPoint (0, 3, 0);
        Instantiate (yeniObje, yeniObjePozisyonu, yeniObje.transform.rotation);
    }

TransformVector : Objenin local yapısına göre elde ettiğimiz Vector3 cinsinden vektör değerlerini genel koordinat sistemine uyarlamamızı sağlar. Objenin rotasyonu ve boyutları hesaplamada etkilidir.

Translate : Objeyi transform bileşenini kullanarak adım adım hareket ettirmemizi sağlar. Vector3 cinsinden hareket büyüklüğünü değişken olarak alır. Ayrıca local veya genel koordinat sistemini kullanmayı seçebiliriz. Eğer local seçersek verilen vector3 değişkeni local olarak değerlendirilir. Yani Vector3.up verirsek, objenin yukarı yönü neresi ise oraya hareket eder. Ancak genel, global ekseni seçersek verdiğimi Vector3 değeri direkt uygulanır. Örnekte ikisi arasındaki farkı gösterdim.

    //objenin rotasyon değerleriyle oynamayı unutmayın
    void Update () {
        //objeyi kendi yukarı, y ekseninde 1 birim ilerletir.
        if (Input.GetKeyDown (KeyCode.W)) {
            transform.Translate (Vector3.up);
        }
        //objeyi genel yukarı, y ekseninde 1 birim ilerletir.
        if (Input.GetKeyDown (KeyCode.Space)) {
            transform.Translate (Vector3.up, Space.World);
        }
    }

Kodları da tamamladığımıza göre, az çok Unity Transform Nedir? sorusunun cevabı iyice kafanıza yerleşmiştir diye umuyorum. Kaynağı türkçeleştirmeye çalışsam da, orjinal dökuman üzerinden de inceleme yapmak isterseniz Unity Transform üzerinden erişebilirsiniz.