Spawned Object Gradient Mesh Colors?

Question

Hi there, so I am trying to make a game similar to the stack game by Ketchapp based on this tutorial: https://www.youtube.com/watch?v=I19cC_HcyC0

I've already finished the tutorial and am now just making my own changes to make it my own project. One of the things the creator doesn't go over is a gradual change in color for each of the objects in the stack.

The version in the tutorial uses this code here:

 public Color32[] gameColors = new Color32[4];
 
  private void ColorMesh(Mesh mesh)
     {
         Vector3[] vertices = mesh.vertices;
         Color32[] colors = new Color32[vertices.Length];
         float f = Mathf.Sin(scoreCount * 0.25f);
 
         for (int i = 0; i < vertices.Length; i++)
             colors[i] = Lerp4(gameColors[0], gameColors[1], gameColors[2], gameColors[3], f);
 
         mesh.colors32 = colors;
     }
 
 private Color32 Lerp4(Color32 a, Color32 b, Color32 c, Color32 d, float t)
     {
         if (t < 0.33f)
         {
             return Color.Lerp(a, b, t / 0.33f);
         }
         else if (t < 0.33f)
         {
             return Color.Lerp(b, c, (t - 0.33f) / 0.33f);
         }
         else
             return Color.Lerp(c, d, (t - 0.66f) / 0.66f);
     }

I thought by increasing the number of colors within the array and adding that to the Lerp would solve this. Only to realize this is in fact randomly chosen instead of a set change. I don't really have any experience with Mesh Color related coding so I'm wondering how I could go about changing this to just consistently change the color overtime?

Any help would be appreciated, Thank you!

Answer 1

Are you trying to do something similar to this ? (For the colors I mean) : https://www.youtube.com/watch?v=ad5HoAUyJao

If so, I used the HSB/HSV colors (https://en.wikipedia.org/wiki/HSL_and_HSV) and colorized the obstacles like this :

 go.GetComponentInChildren<Renderer>().material.color = new HSBColor(Mathf.PingPong(Time.time / 10.0f, 1.0f), 1.0f, 0.7f).ToColor();

An here's the content of HSBColors.cs (I edited the script, but it's not mine, I can't remember where I found it, sorry) :

 using UnityEngine;
 using System.Collections;
 
 [System.Serializable]
 public class HSBColor
 {
     public float h;
     public float s;
     public float b;
     public float a;
 
     public HSBColor(float h, float s, float b, float a)
     {
         this.h = h;
         this.s = s;
         this.b = b;
         this.a = a;
     }
 
     public HSBColor(float h, float s, float b)
     {
         this.h = h;
         this.s = s;
         this.b = b;
         this.a = 1f;
     }
 
     public HSBColor(Color col)
     {
         HSBColor temp = FromColor(col);
         h = temp.h;
         s = temp.s;
         b = temp.b;
         a = temp.a;
     }
 
     public static HSBColor FromColor(Color color)
     {
         HSBColor ret = new HSBColor(0f, 0f, 0f, color.a);
 
         float r = color.r;
         float g = color.g;
         float b = color.b;
 
         float max = Mathf.Max(r, Mathf.Max(g, b));
 
         if (max <= 0)
         {
             return ret;
         }
 
         float min = Mathf.Min(r, Mathf.Min(g, b));
         float dif = max - min;
 
         if (max > min)
         {
             if (g == max)
             {
                 ret.h = (b - r) / dif * 60f + 120f;
             }
             else if (b == max)
             {
                 ret.h = (r - g) / dif * 60f + 240f;
             }
             else if (b > g)
             {
                 ret.h = (g - b) / dif * 60f + 360f;
             }
             else
             {
                 ret.h = (g - b) / dif * 60f;
             }
             if (ret.h < 0)
             {
                 ret.h = ret.h + 360f;
             }
         }
         else
         {
             ret.h = 0;
         }
 
         ret.h *= 1f / 360f;
         ret.s = (dif / max) * 1f;
         ret.b = max;
 
         return ret;
     }
 
     public static Color ToColor(HSBColor hsbColor)
     {
         float r = hsbColor.b;
         float g = hsbColor.b;
         float b = hsbColor.b;
         if (hsbColor.s != 0)
         {
             float max = hsbColor.b;
             float dif = hsbColor.b * hsbColor.s;
             float min = hsbColor.b - dif;
 
             float h = hsbColor.h * 360f;
 
             if (h < 60f)
             {
                 r = max;
                 g = h * dif / 60f + min;
                 b = min;
             }
             else if (h < 120f)
             {
                 r = -(h - 120f) * dif / 60f + min;
                 g = max;
                 b = min;
             }
             else if (h < 180f)
             {
                 r = min;
                 g = max;
                 b = (h - 120f) * dif / 60f + min;
             }
             else if (h < 240f)
             {
                 r = min;
                 g = -(h - 240f) * dif / 60f + min;
                 b = max;
             }
             else if (h < 300f)
             {
                 r = (h - 240f) * dif / 60f + min;
                 g = min;
                 b = max;
             }
             else if (h <= 360f)
             {
                 r = max;
                 g = min;
                 b = -(h - 360f) * dif / 60 + min;
             }
             else
             {
                 r = 0;
                 g = 0;
                 b = 0;
             }
         }
 
         return new Color(Mathf.Clamp01(r), Mathf.Clamp01(g), Mathf.Clamp01(b), hsbColor.a);
     }
 
     public Color ToColor()
     {
         return ToColor(this);
     }
 
     public override string ToString()
     {
         return "H:" + h + " S:" + s + " B:" + b;
     }
 
     public static HSBColor Lerp(HSBColor a, HSBColor b, float t)
     {
         float h, s;
 
         if (a.b == 0)
         {
             h = b.h;
             s = b.s;
         }
         else if (b.b == 0)
         {
             h = a.h;
             s = a.s;
         }
         else
         {
             if (a.s == 0)
             {
                 h = b.h;
             }
             else if (b.s == 0)
             {
                 h = a.h;
             }
             else
             {
                 float angle = Mathf.LerpAngle(a.h * 360f, b.h * 360f, t);
                 while (angle < 0f)
                     angle += 360f;
                 while (angle > 360f)
                     angle -= 360f;
                 h = angle / 360f;
             }
             s = Mathf.Lerp(a.s, b.s, t);
         }
         return new HSBColor(h, s, Mathf.Lerp(a.b, b.b, t), Mathf.Lerp(a.a, b.a, t));
     }
 }

Answer 2

Answer by Palass64 · Aug 01, 2017 at 01:46 PM

I'm also having this kind of problem.

Any other option then using HSB/HSV colors ?

Add comment · Share

Spawned Object Gradient Mesh Colors?

2 Replies

Your answer

Follow this Question

Related Questions