# Spawned Object Gradient Mesh Colors?

Hi there, so I am trying to make a game similar to the stack game by Ketchapp based on this tutorial: Stack - Making 'Stack' Android game [C#][Stream VOD] - YouTube

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 *= 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!

Are you trying to do something similar to this ? (For the colors I mean) : AudioGame Gameplay Contest Entry - YouTube

If so, I used the HSB/HSV colors (HSL and HSV - Wikipedia) 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()
{
}

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));
}
}
``````

I’m also having this kind of problem.

Any other option then using HSB/HSV colors ?