Nasıl Renklendirilir.

Unity belgelerinde buna bir çözüm bulmakta zorlandım.

Color.Lerp(Color a, Color b, float t) t, bir basamağa göre bir rengi aşamalı olarak değiştiren ve ona Rengin son değerini veren bir işlevdir b.

Birbiri ardına birden fazla renk arasında nasıl Liderim?

Let _colors renk bir dizi izin olmak BOYU izin dizi renk sayısı, t 0..1 yüzer değer

float scaledTime = t * (float) (LENGHT - 1);
Color oldColor = _colors[(int) scaledTime];
Color newColor = _colors[(int) (scaledTime + 1f)];
float newT = scaledTime - Mathf.Round(scaledTime); 

sonunda Lerp'i kullanabilirsiniz

Color.Lerp(oldColor, newColor, newT)

Birden fazla renk geçişi ile alınabilecek bir yaklaşım, bir Degradeyi kullanmaktır .

Bu tür bir ortak değişkeni ortaya çıkararak bir geliştirici, herhangi bir sayıda renk içeren bir degrade tasarlamak için Degrade Düzenleyiciyi başlatmak üzere Denetçiyi kullanın. Bu düzenleyici, birlik renk seçicileri kullanmanıza, renk / alfa tuşlarının yerleşimine ince ayar yapmanıza ve degradeleri kaydetmenize / yüklemenize olanak tanır.

Tasarlandıktan sonra Gradient.Evaluate()yöntem, uygun rengi döndürmek için 0-1 aralığında bir şamandırayı kabul edecektir.

using UnityEngine;

public class GradientTest : MonoBehaviour
{
    public Gradient myGradient;
    public float strobeDuration = 2f;

    public void Update() {
        float t = Mathf.PingPong(Time.time / strobeDuration, 1f);
        Camera.main.backgroundColor = myGradient.Evaluate(t);
    }
}

Ne yazık ki, programlı bir Gradient oluşturmak için kullanılan API o kadar zarif değil .

public float every;   //The public variable "every" refers to "Lerp the color every X"
float colorstep;
Color[] colors = new Color[4]; //Insert how many colors you want to lerp between here, hard coded to 4
int i;
Color lerpedColor = Color.red;  //This should optimally be the color you are going to begin with

void Start () {

    //In here, set the array colors you are going to use, optimally, repeat the first color in the end to keep transitions smooth

    colors [0] = Color.red;
    colors [1] = Color.yellow;    
    colors [2] = Color.cyan;
    colors [3] = Color.red;

}


// Update is called once per frame
void Update () {

    if (colorstep < every) { //As long as the step is less than "every"
        lerpedColor = Color.Lerp (colors[i], colors[i+1], colorstep);
        this.GetComponent<Camera> ().backgroundColor = lerpedColor;
        colorstep +=0.025f;  //The lower this is, the smoother the transition, set it yourself
    } else { //Once the step equals the time we want to wait for the color, increment to lerp to the next color

        colorstep = 0;

        if (i < (colors.Length - 2)){ //Keep incrementing until i + 1 equals the Lengh
        i++;
        }
        else { //and then reset to zero
            i=0;
        }
    }
}

Bu benim üç renk arasında lerp için kullanılan kod budur, umarım ben bunu aramaya karar veren herkes için yararlı olacaktır.

Daha iyi bir çözüm olabileceğini hissediyorum. Renkten renge geçmenin tek nedeni, tonu sürekli değiştirmek isteyip istemediğiniz ... http://en.wikipedia.org/wiki/Hue

HSV'yi RGB'ye nasıl dönüştüreceğiniz aşağıda açıklanmıştır: http://en.wikipedia.org/wiki/HSL_and_HSV#From_HSV

Bununla HSV renklerini kullanabilir, tonu değiştirebilir ve ardından RGB'ye dönüştürebilirsiniz. Ayrıca, Color.Lerp ile tutarsızlık probleminiz var. Turuncudan sarıya, sonra yeşile geçerseniz, rengin çok çabuk sarıya başladığını, sonra sarıya yaklaştıkça yavaşlamaya başladığını, sonra sarıya geçtiğinde ve yeşile döndüğünü göreceksiniz. Böylece gittiğiniz her noktada renk değişimini yavaşlatacaktır. Bence tonu değiştirmek çok daha etkili olacaktır - ve uzun vadede daha iyi bir etki yaratacaktır. :)

Kendi versiyonunuzu yazmaya ne dersiniz, hangi kaldıraçları kullanıyorsunuz Color.Lerp()?

3 renk alan ve ikincisini ortaya koyan çok basit bir sürüm şöyle görünebilir:

Color Lerp3(Color a, Color b, Color c, float t)
{
    if (t < 0.5f) // 0.0 to 0.5 goes to a -> b
        return Color.Lerp(a, b, t / 0.5f);
    else // 0.5 to 1.0 goes to b -> c
        return Color.Lerp(b, c, (t - 0.5f) / 0.5f);
}

Rengi ne değiştirmek istediğinizi söylemediğiniz için, yöntemde oluşturulan bir renkle belirsiz bir örnek vereceğim.

Mesele, renklerin bir koleksiyonuna ve toplam süreye (vereceğim örnekte olduğu gibi) veya her biri arasında bir süreye (bu size bağlı) sahip olmaktır.

Kişisel olarak, Güncelleme'de sürekli enterpolasyon yapmayacağımı bildiğim şeyleri enterpolasyon etmiyorum (Kamera bir istisna), bu yüzden bunun için coroutines kullanıyorum.

Bu örnekte, denetçide verilen süreyi renk miktarına bölerim ve sonra gerçek yineleyici rengini bir sonraki yineleyici rengine bağlarım ve süre daha önce eklenmiş olan süreye ait olacaktır. İşte örnek:

public class ColorLerping : MonoBehaviour
{
    public Color sampleColor; /// Just for debugging purposes.
    public float lerpDuration;
    public Color[] colors;

    void Awake()
    {
        StartCoroutine(LerpColors());
    }

    private IEnumerator LerpColors()
    {
        if(colors.Length > 0)
        {
            /// Split the time between the color quantities.
            float dividedDuration = lerpDuration / colors.Lenght;

            for(int i = 0; i < colors.Length - 1; i++)
            {
                float t = 0.0f;

                while(t < (1.0f + Mathf.Epsilon))
                {
                    sampleColor = Color.Lerp(colors[i], colors[i + 1], t);
                    t += Time.deltaTime / dividedDuration;
                    yield return null;
                }

                // Since it is posible that t does not reach 1.0, force it at the end.
                sampleColor = Color.Lerp(colors[i], colors[i + 1], 1.0f);
            }

        }
        else yield return null; /// Do nothing if there are no colors.
    }
}

Umarım yardımcı olur.