कैसे रंग के लिए। कई रंगों के बीच।
जवाबों:
चलो _colors रंग की एक सरणी जाने होना लंबाई सरणी में रंगों की संख्या हो टी 0..1 नाव मान होना
float scaledTime = t * (float) (LENGHT - 1);
Color oldColor = _colors[(int) scaledTime];
Color newColor = _colors[(int) (scaledTime + 1f)];
float newT = scaledTime - Mathf.Round(scaledTime);
अंत में आप Lerp का उपयोग कर सकते हैं
Color.Lerp(oldColor, newColor, newT)एक दृष्टिकोण जिसे कई रंग संक्रमणों के साथ लिया जा सकता है, वह है ग्रेडिएंट का लाभ उठाना ।
इस प्रकार के एक सार्वजनिक चर को उजागर करने से एक डेवलपर किसी भी संख्या में रंगों वाले ग्रेडिएंट को डिजाइन करने के लिए ग्रैडिएंट एडिटर को लॉन्च करने के लिए इंस्पेक्टर का उपयोग करता है। यह संपादक आपको एकता रंग बीनने वाले, रंग की अच्छी धुन प्लेसमेंट / अल्फा कुंजी का उपयोग करने और / लोड ग्रेडिएंट को बचाने की अनुमति देता है।
एक बार तैयार की गई Gradient.Evaluate()विधि उपयुक्त रंग वापस करने के लिए 0-1 की सीमा में एक नाव को स्वीकार करेगी।
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);
}
}दुर्भाग्य से क्रमिक रूप से ग्रेडिएंट के निर्माण के लिए एपीआई उतना सुरुचिपूर्ण नहीं है ।
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;
}
}
}तो यह वह कोड है जो मैंने अपने तीन रंगों के बीच lerp का उपयोग करके समाप्त किया है, मुझे आशा है कि मैं किसी ऐसे व्यक्ति के लिए उपयोग करूंगा जो इसके लिए देखने का निर्णय लेता है।
मुझे लगता है कि कोई बेहतर उपाय हो सकता है। एक ही कारण है कि मैं रंग से रंग की ओर देखना चाहूंगा यदि आप लगातार रंग बदलना चाहते हैं ... http://en.wikipedia.org/wiki/Hue
एचएसवी को आरजीबी में बदलने का तरीका यहां बताया गया है: http://en.wikipedia.org/wiki/HSL_and_HSV#F__V
इसके साथ आप HSV रंगों का उपयोग कर सकते हैं, बस ह्यू बदल सकते हैं, फिर RGB में कनवर्ट कर सकते हैं। इसके अलावा, Color.Lerp के साथ, आपको असंगति की समस्या है। यदि आप नारंगी से पीले रंग की ओर, फिर हरे रंग की ओर लेप करते हैं, तो आप पाएंगे कि रंग बहुत जल्दी पीले होने लगता है, फिर धीरे-धीरे पीला होने लगता है, फिर पीले होने से पहले फिर से गति करता है और हरा हो जाता है। इसलिए यह हर उस बिंदु पर रंग बदलने को धीमा कर देगा, जिस पर आप लेट रहे हैं। मुझे लगता है कि रंग बदलना अधिक प्रभावी होगा - और लंबे समय में, बेहतर प्रभाव देगा। :)
कैसे के बारे में आप अपने खुद के संस्करण लिखते हैं, जो लाभ उठाता है Color.Lerp()?
एक बहुत ही सरल संस्करण जो 3 रंग लेता है, और बीच में दूसरा सही डालता है, इस तरह दिख सकता है:
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);
}चूँकि आपने यह नहीं बताया कि आप किस रंग को बदलना चाहते हैं, इसलिए मैं विधि पर बनाए गए रंग के साथ एक अस्पष्ट उदाहरण दूंगा।
बिंदु के पास रंगों का एक संग्रह है, और कुल में एक अवधि (जैसे उदाहरण मैं प्रदान करेगा) या हर एक के बीच की अवधि (जो आपके ऊपर है)।
मैं व्यक्तिगत रूप से अद्यतन पर चीजों को प्रक्षेपित नहीं करता हूं जो मुझे पता है कि मैं लगातार प्रक्षेप नहीं करूंगा (कैमरा एक अपवाद है), इसलिए मैं इसे संभालने के लिए कोरटाइन का उपयोग करता हूं।
इस उदाहरण पर, मैं इंस्पेक्टर पर दी गई अवधि को रंगों की मात्रा से विभाजित करता हूं, और फिर मैं अगले पुनरावृत्त रंग को वास्तविक पुनरावृत्ति रंग देता हूं, और अवधि पहले से लटकी हुई अवधि की होगी। यहाँ नमूना है:
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.
}
}आशा करता हूँ की ये काम करेगा।