Karadot Games

Start: Obje ilk yaratıldığı anda herhangi bir update fonksiyonu çağrılmaya başlanmadan önce çağrılan fonksiyondur. Yazdığınız script’e dair genel ayarlamaları yapmak için uygundur.

Update: Bileşen aktif olduğu sürece her bir karede çağrılan fonksiyondur.

using UnityEngine;

public class StartUpdateExample : MonoBehaviour {

    Material material;
    //Renderer bileşenine erişmeye çalışıp materyali değişkene alıyoruz, renderer yoksa uyarı veriyoruz.

    private void Start () {
        if (TryGetComponent<Renderer> (out Renderer renderer)) {
            material = renderer.material;
        } else {
            Debug.LogError ("Objede renderer olmalı");
            //eğer editörde çalışıyorsak play moddan çıkış yapıyoruz, diğer durumda uygulamayı kapatıyoruz.
#if UNITY_EDITOR
            UnityEditor.EditorApplication.isPlaying = false;
#else
            Application.Quit ();
#endif
        }
    }

    //Update fonksiyonu her bir karede(frame) çalışacaktır.
    private void Update () {
        //WASD tuşlarına basıldığında objeyi hareket ettirip materyal rengini değiştiriyoruz.
        if (Input.GetKeyDown (KeyCode.A)) {
            transform.position += Vector3.left;
            material.color = Color.black;
        }
        if (Input.GetKeyDown (KeyCode.D)) {
            transform.position += Vector3.right;
            material.color = Color.white;
        }
        if (Input.GetKeyDown (KeyCode.W)) {
            transform.position += Vector3.forward;
            material.color = Color.blue;
        }
        if (Input.GetKeyDown (KeyCode.S)) {
            transform.position += Vector3.back;
            material.color = Color.red;
        }

        //Her karede global Y ekseninde, 1 saniyede 360 derece döndürüyoruz
        transform.Rotate (Vector3.up * 360 * Time.deltaTime);
    }
}

Awake: Awake fonksiyonu oyun çalışırken scriptin yüklendiği ilk anda çağırılan fonksiyondur. 

FixedUpdate: FPS değerinden farklı olarak, sabit zaman aralıklarıyla çalışan fonksiyondur. Update fonksiyonuna benzese de, elde edilen kare sayısından bağımsız olduğundan dolayı, fizik işlemlerini uygulamak amacıyla kullanıma daha uygundur. 

using UnityEngine;

public class AwakeFixedUpdateExample : MonoBehaviour {

    public float jumpForce = 15f;
    Rigidbody rigidbody;

    //Başlangıçta rigidbody değişkenine erişip bir değişkende saklıyoruz.
    void Awake () {
        rigidbody = GetComponent<Rigidbody> ();
    }

    //Space tuşuna basıldığında belirtilen büyüklükte yukarı yönlü bir kuvvet uyguluyoruz. 
    void FixedUpdate () {
        if (Input.GetKeyDown (KeyCode.Space))
            rigidbody.AddForce (Vector3.up * jumpForce, ForceMode.Impulse);
    }
}

Reset: Inspector panelinde bulunan bileşene ait ayarlar menüsünde bulunan Reset butonuna basıldığı anda çağrılır, temelde yaptığı şey bütün değişken değerlerini sıfırlamaktır. Bu değişkenleri kendinize göre ayarlamak için bunu fonksiyonu kullanabilirsiniz. Örneğin oyuncuyu takip edecek bir objede “target” değişkeni Reset ile null hale gelecektir. Player etiketine sahip objeyi bulup atama yapmasını sağlayabilirsiniz. 

using UnityEngine;

public class ResetExample : MonoBehaviour {
    [SerializeField]
    Transform target;

    private void Reset () {
        GameObject player = GameObject.FindGameObjectWithTag ("Player");
        if (player != null)
            target = player.transform;
        else
            Debug.LogWarning ("Sahnede 'Player' tagına sahip obje yok");
    }
}

OnDestroy: Bileşenin kendisi veya obje bir şekilde yok edildiğinde (destroy), veya yeni sahneye geçildiğinde, uygulama kapatıldığında da çağırılacak fonksiyondur. 

OnDisable: Obje veya bileşen deaktif hale geldiğinde çağırılan fonksiyondur. Ayrıca herhangi bir şekilde yok edilmeleri durumunda da çağırılacaktır.

OnEnable: Obje aktif hale geldiği anda çağrılan fonksiyondur. 

using UnityEngine;

public class ActiveDeactiveState : MonoBehaviour {
    private void OnDestroy () {
        print (transform.name + " isimli obje yok edildi");
    }
    private void OnDisable () {
        print (transform.name + " isimli obje deaktif hale getirildi");
    }
    private void OnEnable () {
        print (transform.name + " isimli obje aktif hale getirildi");
    }
}

OnApplicationFocus: Geliştirdiğimiz oyun veya uygulamanın o an aktif mi yoksa arkaplanda mı olduğunu elde etmemizi sağlayan fonksiyondur. True veya false değer elde etmemizi sağlar. Dikkat edilecek bir diğer şey de, unity dokümanlarına göre, Android sistemlerde klavye açılırsa bu fonksiyon false değer alacaktır, yani oyun odak noktası olmayacaktır artık. 

OnApplicationPause : Uygulamanın sistem tarafından durdurulup durdurulmadığını anlamamızı ve ona göre işlemler yapmamızı sağlayan fonksiyondur. OnApplicationFocus ile benzer şekilde çalışıyor gibi görünse de, birbirlerinden farklıdırlar. 

using System.Collections;
using UnityEngine;

public class AppPaused : MonoBehaviour
{
    bool isPaused = false;

    void OnGUI()
    {
        if (isPaused)
            GUI.Label(new Rect(100, 100, 50, 30), "Game paused");
    }

    void OnApplicationFocus(bool hasFocus)
    {
        isPaused = !hasFocus;
    }

    void OnApplicationPause(bool pauseStatus)
    {
        isPaused = pauseStatus;
    }
}

OnApplicationQuit: Uygulamadan çıkış yapılmadan önce işlemler yapmamız için kullanabileceğimiz fonksiyon. Oyuncunun durumunu kayıt gibi işlemleri burada gerçekleştirebiliriz. 

using UnityEngine;

public class LevelManager : MonoBehaviour {
    int currentLevelID;

    private void OnApplicationQuit () {
        //varolan sahne ID değerini alıp playerPrefs üzerinden kayıt alıyoruz.
        PlayerPrefs.SetInt ("LastLevelID", currentLevelID);
        PlayerPrefs.Save ();
    }
}

OnAudioFilterRead: Audio Source üzerinden gelen veriyi manipüle etmemizi sağlayan fonksiyondur. Bu sayede varolan sesleri manipüle edebiliriz veya prosedüral olarak ses yaratabiliriz.

using UnityEngine;

//Bu örnekte prosedural olarak verilen hızda metronom sesi çaldırma işlemi gerçekleştirilmektedir.
[RequireComponent (typeof (AudioSource))]
public class OnAudioFilterReadExample : MonoBehaviour {
    public double bpm = 140.0F;
    public float gain = 0.5F;
    public int signatureHi = 4;
    public int signatureLo = 4;

    private double nextTick = 0.0F;
    private float amp = 0.0F;
    private float phase = 0.0F;
    private double sampleRate = 0.0F;
    private int accent;
    private bool running = false;

    void Start () {
        accent = signatureHi;
        double startTick = AudioSettings.dspTime;
        sampleRate = AudioSettings.outputSampleRate;
        nextTick = startTick * sampleRate;
        running = true;
    }

    /*
    OnAudioFilterRead ile 2 tipte veri geliyor bize. 
    gelen veriler üzerinde oynamalar yaparak istediğimiz hızda bir metronom sesi yaratıyoruz.
    Herhangi bi dosya vermemize gerek kalmıyor.
    */
    void OnAudioFilterRead (float[] data, int channels) {
        if (!running)
            return;

        double samplesPerTick = sampleRate * 60.0F / bpm * 4.0F / signatureLo;
        double sample = AudioSettings.dspTime * sampleRate;
        int dataLen = data.Length / channels;

        int n = 0;
        while (n < dataLen) {
            float x = gain * amp * Mathf.Sin (phase);
            int i = 0;
            while (i < channels) {
                data[n * channels + i] += x;
                i++;
            }
            while (sample + n >= nextTick) {
                nextTick += samplesPerTick;
                amp = 1.0F;
                if (++accent > signatureHi) {
                    accent = 1;
                    amp *= 2.0F;
                }
                Debug.Log ("Tick: " + accent + "/" + signatureHi);
            }
            phase += amp * 0.3F;
            amp *= 0.993F;
            n++;
        }
    }
}

OnBecameInvisible: Scriptin bulunduğu objenin kameranın görüşünde çıktığı an istediğimiz işlemleri gerçekleştirmemizi sağlayan fonksiyondur. 

OnBecameVisible: Scriptin bulunduğu objenin kamerada görünür hale geldiğinde çağırılan fonksiyondur. 

using UnityEngine;

//Sadece kamerada görünür olmadığı durumlarda hedefi takip etme işlemini gerçekleştiren script
public class WeepingAngel : MonoBehaviour {

    [SerializeField]
    Transform target;
    [SerializeField]
    float speed = 15;

    bool canMove = false;

    private void OnBecameVisible () {
        canMove = false;
    }

    private void OnBecameInvisible () {
        canMove = true;
    }
    //hareket edebilir (canMove) değeri false ise  return komutu ile fonksiyonu direkt geri döndürüyoruz, yani return satırı sonrasına geçmiyor işlemler.
    //eğer true değere sahipse, hedef objeye doğru hareket ettiriyoruz.
    private void Update () {
        if (!canMove)
            return;
        //hedef konumundan varolan konumumuzu çıkardığımızda gitmemiz gereken yönü elde ediyoruz. 
        Vector3 direction = target.position - transform.position;
        //Daha sonra elde ettiğimiz vektörü 1 birim uzunluğa sahip olacak şekile getiriyoruz, normalleştiriyoruz.
        direction.Normalize ();
        //ardından direction, yön değerini kullanarak objemizi hareket ettiriyoruz.
        transform.position += direction * speed * Time.deltaTime;
    }
}

using UnityEngine;

public class Fire : MonoBehaviour {
    [SerializeField]
    float damageAmount;

    //temas başladığı anda temasa başlanan objenin hasar alabilir (Damageble) isimli bileşene sahip olup olmadığını kontrol ediyoruz.
    private void OnCollisionEnter (Collision other) {
        other.gameObject.TryGetComponent<Damageble> (out Damageble damageble);
        //Eğer damageble bileşeni varsa, hasar alma efektlerini aktif hale getiriyoruz.
        if (damageble != null) {
            Debug.Log (damageble.damagebleName + "isimli obje yakılmaya başlandı.");
            damageble.ActivateDamageEffect (true);
        }
    }
    //temas bittiği anda temas halindeki objenin hasar alabilir (Damageble) isimli bileşene sahip olup olmadığını kontrol ediyoruz.
    private void OnCollisionExit (Collision other) {
        other.gameObject.TryGetComponent<Damageble> (out Damageble damageble);
        //Eğer damageble bileşeni varsa, hasar alma efektlerini deaktif hale getiriyoruz.
        if (damageble != null) {
            damageble.ActivateDamageEffect (false);
            Debug.Log (damageble.damagebleName + "isimli obje söndü.");
        }
    }
    private void OnCollisionStay (Collision other) {
        other.gameObject.TryGetComponent<Damageble> (out Damageble damageble);
        if (damageble != null) {
            /*Eğer damageble bileşeni varsa, DoDamage fonksiyonu ile hasar uyguluyoruz.
            Aynı update gibi temas olduğu her an, her karede çalıştığı için 
            Time.deltaTime ile hasar değerimizi çarparak, 1 kare geçişinde ne kadarlık hasar
            vermek istediğimizi belirtiyoruz.
            */
            damageble.DoDamage (damageAmount * Time.deltaTime);
            Debug.Log (damageble.damagebleName + "hâlâ yanıyor.");
        }
    }
}

//Damageble isimli bir script yaratıp o dosyaya koymayı unutmayın.
public class Damageble : MonoBehaviour {
    [SerializeField]
    float health = 100;

    public string damagebleName = "Object";

    [SerializeField]
    ParticleSystem damageEffect;

    //Health değerini verilmek istenen hasar kadar azaltıyoruz, ardından 0'ın altına indiyse objeyi yok ediyoruz.
    public void DoDamage (float damageAmount) {
        health -= damageAmount;

        if (health <= 0) {
            Debug.Log (damagebleName + "isimli obje yok oldu");
            Destroy (gameObject);
        } else {
            Debug.Log (damagebleName + "isimli obje " + damageAmount + " kadar hasar aldı, anlık sağlığı" + health);
        }
    }
    //Hasar alma efektlerinin açılıp kapanması için kullanacağımız fonksiyon.
    public void ActivateDamageEffect (bool isActive) {
        if (isActive)
            damageEffect.Play ();
        else
            damageEffect.Stop ();
    }
}

OnCollison fonksiyonlarında dikkat ederseniz Collison tipinde bir değişken belirtmemiz gerekiyor. Bu veri Unity tarafından bize sağlanıyor. Örnekte kullanmadık ancak Collision tipi veriler içerisinde temas etme noktaları, temas edilen objenin collider ve rigidbody gibi bileşenleri bulunmakta. Daha detaylı bilgi elde etmek isterseniz, Unity Collision dokümanına göz atabilirsiniz. Türkçe çevirisi de yakında sitemize eklenecektir 🙂

OnCollisionExit2D: 2D fizik sistemine sahip bir objenin başka bir obje ile teması bittiği an çağırılan fonksiyondur. 

OnCollisionEnter2D: 2D fizik sistemi kullanan objenin başka bir objeye temas ettiği, değdiği an çalışan fonksiyondur. 

OnCollisionStay2D: 2D fizik sistemine sahip bir objenin başka bir obje ile teması sürdüğü sürece her bir karede çağırılan fonksiyondur. 

Yazının öncesinde kullandığımız Collision örneğini de 2D için kullanabilirsiniz. Yalnız dikkat etmeniz gereken şey, objelerde Rigidbody2D ve Collider2D bileşenlerinin olması. Eğer 3d için olan fizik bileşenlerik kullanırsanız 2D fonksiyonları çalışmayacaktır. Ayrıca 2D versiyonlarda Collision yerine Collision2D tipinde değişken kullanıyoruz. Collision2D tipindeki verilerle hangi değişkenlere erişebileceğinizi Unity Collision2D dokümanından inceleyebilirsiniz.

using UnityEngine;

//Character Controller bileşeni ile hareket ettirilen bir objenin 
//Rigidbody bileşenine sahip olduğu objeleri ittirmesini sağlayan komut.
public class CharacterControllerInteractions : MonoBehaviour {
    public float pushPower = 2.0F;

    void OnControllerColliderHit (ControllerColliderHit hit) {
        //temas edilen objedeki rigidbody bileşenine erişiyoruz.
        Rigidbody body = hit.collider.attachedRigidbody;

        //Temas edilen objede rigidbody yok veya kinematic halde ise return ile hiçbir şey yapmadan dönüyoruz.
        if (body == null || body.isKinematic)
            return;

        // eğer Character Controller aşağı doğru hareket ediyorsa, aşağımızda bulunan objeleri itmek istemeyiz bu yüzden yine geri dönüyoruz. 
        if (hit.moveDirection.y < -0.3f)
            return;

        //Gittiğimiz yöne göre temas ettiğimiz objeye uygulanacak itme için yön belirliyoruz.
        Vector3 pushDir = new Vector3 (hit.moveDirection.x, 0, hit.moveDirection.z);
        //Elde ettiğimiz yön değerini itme kuvveti ile çarparak temas edilen objenin velocity, hareket değerine atıyoruz.
        //Eğer karakterinizin gitmesini istediğiniz belirli bir hız varsa, bunu da çarpım işlemine ekleyebilirsiniz.
        body.velocity = pushDir * pushPower;
    }
}

Rigidbody bileşenine dair daha detaylı bilgi edinmek isterseniz Unity Rigidbody Nedir? yazımıza göz atabilirsiniz.

using UnityEngine;

public class OnDrawGizmosExample : MonoBehaviour {

    float areaRadius = 3;

    //Objenin bulunduğu konumda, mavi renkte, 1 birimlik ölçülere sahip bir küp çizdiriyoruz ekranda.
    //Böylece objeyi diğerlerinden ayırt etme ve seçme işlemlerini daha rahat gerçekleştirebiliyoruz.
    private void OnDrawGizmos () {
        Gizmos.color = Color.blue;
        Gizmos.DrawCube (transform.position, Vector3.one);
    }
    //Objeyi seçtiğimiz anda kırmızı renkli, çizgilerden oluşan bir daire çiziyoruz.
    //Örneğin bir kuleniz var ve belirli alana giren düşmanlara saldırabilmesini istiyorsunuz.
    //AreaRadius değişkeni ile oynayarak ne kadarlık alanda saldırı yapabileceğini görsel olarak tespit etmeniz kolaylaşacaktır.
    private void OnDrawGizmosSelected () {
        Gizmos.color = Color.red;
        Gizmos.DrawWireSphere (transform.position, areaRadius);
    }
}

OnDrawGizmos fonksiyonlarında, Gizmos sınıfını kullandığımızı farketmişsinizdir. Gizmos sınıfına dair daha detaylı bilgi edinmek için Unity Gizmos Sınıfı yazımızı inceleyebilirsiniz.

OnGUI: Ekran üzerinde arayüz bileşenlerini kodlar aracılığıyla oluşturmamıza imkan veren fonksiyondur. GUI sınıfı aracılığıyla ekrana butonlar, yazılar, görseller yerleştirmek mümkündür. GUI sınıfı hakkında daha fazla bilgi edinmek için Unity GUI dokümanını inceleyebilirsiniz. Kod ile arayüz oluşturmak biraz zahmetli olsa da veya uygulamanızı yayınlarken kullanmanız önerilmese de, geliştirme sürecinde bazı verileri ekranda göstermek, oyuna daha rahat müdahale etmek gibi amaçlarla kendiniz için arayüzler oluşturabilirsiniz.

using UnityEngine;

public class OnGUIExample : MonoBehaviour {
    int yPos = 10, yHeight = 100;

    //Basit bir buton çizdiriyoruz ve tıklandığında ekranda aşağı hareket ettirip metin yazdırıyoruz.
    private void OnGUI () {
        if (GUI.Button (new Rect (10, yPos, 150, yHeight), "Bana Tıkla!!")) {
            print ("Oha bana tıkladın!");
            MoveDown ();
        }
    }
    //ypos değerini butonun yüksekliği kadar arttırdığımızda ekranda kendi boyu kadar yer değiştirmiş olacak.
    void MoveDown () {
        yPos += yHeight;
    }
}

OnJointBreak: Birbirine Joint bileşeni ile bağlı objelerin uygulanan kuvvet sebebiyle birbirinden ayrılması, kopması durumunda çağrılan fonksiyondur. Kopmaya sebep olan kuvveti float cinsinden bize vermektedir.

using UnityEngine;

public class OnJointBreakExample : MonoBehaviour {
    private void OnJointBreak (float breakForce) {
        print (transform.name + " isimli objeye ait joint " + breakForce + " büyüklüğünde kuvvet ile ayrıldı.");
    }
}

OnJointBreak2D: 2D fizik objelerinde birbirine 2D Joint ile bağlanmış objelerin, uygulanan kuvvet sonucu birbirinden ayrılması, kopması durumunda çağrılan fonksiyondur. Joint2D tipinde değeri bize vermektedir.

using UnityEngine;

public class OnJointBreak2DExample : MonoBehaviour {
    private void OnJointBreak2D (Joint2D brokenJoint) {
        print (transform.name + " isimli obje " + brokenJoint.reactionForce +
            " kuvveti ve " + brokenJoint.reactionTorque + " torku ile koptu.");
    }
}

OnMouseEnter: Fare imleci collider bileşenine sahip objenin üzerine getirildiği anda çağrılan fonksiyondur.

OnMouseExit: Fare imleci objenin üzerinden çekildiği an çağrılan fonksiyondur. 

OnMouseOver: Fare imleci objenin üzerinde durduğu süre boyunca, her karede çağrılan fonksiyondur.

using UnityEngine;

public class OnMouseExamples : MonoBehaviour {
    public Renderer rend;

    float colorTimer;

    //Başlangıçta renderer bileşenine erişiyoruz.
    void Start () {
        rend = GetComponent<Renderer> ();
    }

    //Fare ile üzerine geldiğimizde materyal rengini kırmızı yapıyoruz ve colorTimer değerini sıfırlıyoruz
    void OnMouseEnter () {
        rend.material.color = Color.red;
        colorTimer = 0;
    }

    //Fare objenin üzerinde durduğu sürece, rengi kırmızıdan maviye döndürüyoruz.
    //Color.Lerp fonksiyonu iki renk arasında geçiş yapmamızı sağlıyor, 3. değişken olan colorTimer 0 ise ilk değer, 1 ise 2.değer dönüyoruz
    //.5f verirsek de tam ikisinin arasında bir renk değeri elde ederiz. 
    void OnMouseOver () {
        colorTimer += Time.deltaTime;
        rend.material.color = Color.Lerp (Color.red, Color.blue, colorTimer);
    }

    //Fareyi objenin üzerinden çektiğimiz anda tekrar beyaz renge döndürüyoruz.
    void OnMouseExit () {
        rend.material.color = Color.white;
    }
}

OnMouseDown: Collider bileşenine sahip bir objenin üzerine fare ile tıklandığında çağrılan fonksiyondur.

OnMouseDrag: Collider bileşenine sahip bir objenin üzerine fare ile tıklandığında ve tıklama bırakılmadan fare hareket ettirildiği süre boyunca çağrılan fonksiyondur.

OnMouseUp: Fare imleci objenin üzerindeyken fareye tıklama bırakıldığı anda çağrılan fonksiyondur. Ancak dikkat etmekte fayda var, a objesinin üzerindeyken tıklama işlemi yapılıp, daha sonrasında tıklama devam ederken b objesinin üzerine gelip, tıklama bırakılırsa bu fonksiyon yine çalışacaktır. Yani tıklanan obje ile tıklamanın bırakıldığı obje aynı objeler olmak zorunda değildir. 

using UnityEngine;

public class OnMouseInteraction : MonoBehaviour {
    Vector3 startScale;
    Vector3 oldMousePosition;
    //fare ile tıkladığı anda objenin boyutlarını ve farenin tıklama anındaki konumunu değişkenlere saklıyoruz.
    private void OnMouseDown () {
        startScale = transform.localScale;
        oldMousePosition = Input.mousePosition;
    }
    //Tıklama bırakıldığı anda objeyi eski boyutuna döndürüyoruz.
    private void OnMouseUp () {
        transform.localScale = startScale;
    }
    //Fare objeye tıklanılmış halde hareket ettirilirken fare pozisyonunun ne kadar değiştiğini elde edip
    //hareket büyüklüğüne göre objenin boyutunu arttırıyoruz.
    private void OnMouseDrag () {
        Vector3 movement = oldMousePosition - Input.mousePosition;
        transform.localScale += Vector3.one * Time.deltaTime * movement.magnitude;
        oldMousePosition = Input.mousePosition;
    }
}

OnPostRender: Kameranın her bir karede render işlemini bitirmesinin ardından çağrılan fonksiyondur.

OnPreCull: Culling işlemi gerçekleşmeden önce çağrılan fonksiyondur.

OnPreRender: Kamera objesinin sahneyi render etme işlemini gerçekleştirmeden önce çağrılan fonksiyondur..

using UnityEngine;

//Kamera objesine eklenmeli
//Kameradan elde edilen görüntüyü yatayda ters hale getiren script
public class FlipRenderHorizontal : MonoBehaviour {
    Camera cam;

    //Camera bileşenine erişiyoruz
    void Start () {
        cam = GetComponent<Camera> ();
    }

    //Cull işlemi yapmadan önce matarix resetlemesi yapıp daha sonrasında matrix'i yatayda ters dönecek hale getiriyoruz.
    void OnPreCull () {
        cam.ResetWorldToCameraMatrix ();
        cam.ResetProjectionMatrix ();
        cam.projectionMatrix = cam.projectionMatrix * Matrix4x4.Scale (new Vector3 (1, -1, 1));
    }

    //PreRender ve PostRender fonksiyonlarında arka yüzlerin algılanma durumunu açıp kapatıyoruz
    //böylece matrix değiştirme sebebiyle yüzeylerin algılanmama, render edilmeme durumlarını önlüyoruz.
    void OnPreRender () {
        GL.invertCulling = true;
    }
    void OnPostRender () {
        GL.invertCulling = false;
    }
}

OnRenderImage: Kamera objesinin sahneyi render etme işleminin tamamlanması ardından çağrılan fonksiyondur. Render sonucu elde edilen görüntüyü manipüle etmeniz mümkündür..

using UnityEngine;
//Script kamera objesinde olmalı
public class OnRenderImageExample : MonoBehaviour {
    /*
    Resim işlemede kullanılacak materyal
    Sprite/Default shader'ı kullanan bir materyal yaratıp beyaz dışında farklı bir renk seçerseniz
    kamera görüntüsünün üzerine o renk eklendiğini göreceksiniz. Eğer sadece renk görünüyorsa, 
    materyal üzerinden rengin alpha değerini azaltın.
    */
    public Material mat;

    void OnRenderImage (RenderTexture src, RenderTexture dest) {
        //Graphics sınıfı yardımıylz, src yani kameranın okuduğu görüntüye
        //istediğimiz materyali uygulayıp dest yani çıktı değerini oluşturuyoruz.
        Graphics.Blit (src, dest, mat);
    }
}

OnRenderObject: Obje ekranda render edildikten sonra çağrılan fonksiyondur. OnPostRender işleminden farklı olarak, kamera objesinde değil, render edilen objelerde çağrılır. Bu sayede her obje için farklı işlemler gerçekleştirmek mümkün olur.

using UnityEngine;

public class OnRenderObjectExample : MonoBehaviour {
    public Mesh mainMesh;
    public Mesh miniMapMesh;

    void OnRenderObject () {
        //Render eden camera ismine bakarak farklı mesh objeleri çizdirmemizi sağlayan fonksiyondur.
        //Minimap kamera oluşturup tepeden bakacak şekilde yerleştirdikten sonra, harita üzerinde
        //ikonlar halinde objeleri göstermemiz mümkündür. Tabii bu oldukça basit bir yöntem.
        if (Camera.current.name == "MiniMapcam") {
            Graphics.DrawMeshNow (miniMapMesh, transform.position, transform.rotation);
        } else {
            Graphics.DrawMeshNow (mainMesh, transform.position, transform.rotation);
        }
    }
}

OnTriggerEnter: İki objeden birinin Trigger özelliğine sahip Colllider bileşeni içerdiği  temas etme durumunda çağrılan fonksiyondur. Ayrıca objelerden en az birinin Rigidbody bileşenine sahip olması gerekir. 

OnTriggerExit: İki objeden birinin Trigger özelliğine sahip Colllider bileşeni içerdiği  temas etme ve iç içe girmiş olma durumunun bittiği anda çağrılan fonksiyondur. Ayrıca objelerden en az birinin Rigidbody bileşenine sahip olması gerekir.

OnTriggerStay: İki objeden birinin Trigger özelliğine sahip Colllider bileşeni içerdiği  temas etme durumu devam ettiği sürece çağrılan fonksiyondur. Ayrıca objelerden en az birinin Rigidbody bileşenine sahip olması gerekir..

using UnityEngine;

public class OnTriggerExamples : MonoBehaviour {

    float speed = 5;

    private void Update () {
        float horizontal = Input.GetAxis ("Horizontal");
        float vertical = Input.GetAxis ("Vertical");
        transform.position += new Vector3 (horizontal, 0, vertical) * speed * Time.deltaTime;
    }
    //SlowArea tagına sahip objeye giriş ve çıkış anında hız değerini değiştiriyoruz
    private void OnTriggerEnter (Collider other) {
        if (other.CompareTag ("SlowArea"))
            speed = 2;
    }
    private void OnTriggerExit (Collider other) {
        if (other.CompareTag ("SlowArea"))
            speed = 5;
    }
    //RotateArea isimli objenin içine girdikten sonra, dışına çıkana kadar objeyi global y ekseninde saniye 90 derece döndürüyoruz.
    private void OnTriggerStay (Collider other) {
        if (other.CompareTag ("RotateArea"))
            transform.Rotate (Vector3.up * 90 * Time.deltaTime);
    }
}

OnTrigger örnekleri için aslında 3 adet küp kullandım. 1 tanesi scriptin atandığı karakter, diğer ikisi de farklı alanları temsil etmesi için. Karakter dışındaki küplerin boyutlarını 5 birimlik hale getirdim ve farklı konumlara yerleştirdim. Ayrıca 2 farklı tipte alan kullandım, birinde hareket hız değeri değişirken, diğerinin içinde bulunduğumuz sürece sürekli bir dönme işlemi gerçekleştiriyoruz. İki alanı algılamak adına da tag, etiket sisteminden yararlandım. Bu fonksiyonlarda bize dönen değer Collider tipinde. Bunlar içerisinde çeşitli fonksiyonlar ve değerlere erişmemiz mümkün. Daha önce görmüş olabileceğiniz Box Collider, Capsule collider gibi bütün collider bileşenlerinin atası, miras aldığı sınıf bu. Genel olarak Collider bileşenleri hakkında bilgi almak için Unity Collider Nedir yazımıza göz atabilirsiniz. Örnekte kullandığımız CompareTag fonksiyonu ise GameObject sınıfından gelen bir fonksiyon, ona dair daha fazla bilgi için Unity GameObject Nedir yazımıza göz atabilirsiniz.

OnTriggerEnter2D: 2D fizik işlemlerinde, iki objeden birinin Trigger özelliğine sahip Colllider bileşeni içerdiği  temas etme durumunda çağrılan fonksiyondur. Ayrıca objelerden en az birinin Rigidbody2D bileşenine sahip olması gerekir.

OnTriggerExit2D: 2D fizik işlemlerinde iki objeden birinin Trigger özelliğine sahip Colllider bileşeni içerdiği  temas etme ve iç içe girmiş olma durumunun bittiği anda çağrılan fonksiyondur. Ayrıca objelerden en az birinin Rigidbody2D bileşenine sahip olması gerekir.

OnTriggerStay2D: 2D fizik işlemlerinde iki objeden birinin Trigger özelliğine sahip Colllider bileşeni içerdiği  temas etme  durumu devam ettiği sürece çağrılan fonksiyondur. Ayrıca objelerden en az birinin Rigidbody2D bileşenine sahip olması gerekir.

2D için olan OnTrigger fonksiyonları da işlevsel olarak aynı şekilde çalışıyor, tabii ki Collider2D ve Rigidbody2D kullanmamız şart. Bi fark olarak da tabii ki 3D için olan Collider değil, Collider2D bileşeni döndürüyor bize. Collider2d hakkında daha fazla bilgi edinmek isterseniz Unity Collider2D dokümanına göz atabilirsiniz, yakında onun da Türkçesi geldiğinde linki buraya ekleriz 🙂

OnValidate: Unity Editör üzerinde değişken yüklendiğinde veya üzerindeki değerler değiştiğinde çağrılan fonksiyondur. Değişkenlerin istediğiniz aralıkta olduğundan emin olmak gibi durumlar için kullanabilirsiniz.

using UnityEngine;
using UnityEngine.UI;
//Bir button yaratıp ona eklediğinizden emin olun. 
[RequireComponent (typeof (Button))]
public class OnValidateExample : MonoBehaviour {

    [SerializeField]
    GameObject prefab;

    //Başlangıçta button bileşenine erişip CreatePrefab fonksiyonunu tıklanma durumunda çalışacak şekilde ekliyoruz.
    private void Start () {
        GetComponent<Button> ().onClick.AddListener (() => {
            CreatePrefab ();
        });
    }
    public void CreatePrefab () {
        Instantiate (prefab);
    }
    //Editor yenilendiğinde veya bu bileşendeki bir değişkeni değiştirdiğimizde OnValidate çalışacak ve button text değerini değiştirecek. 
    private void OnValidate () {
        Text prefabNameText = GetComponentInChildren<Text> ();
        prefabNameText.text = "Create " + prefab.name;
    }
}