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);
        }
Exemple #2
0
        public static HSBColor Lerp(HSBColor a, HSBColor b, float t)
        {
            float h, s;

            //check special case black (color.b==0): interpolate neither hue nor saturation!
            //check special case grey (color.s==0): don't interpolate hue!
            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
                {
                    // works around bug with LerpAngle
                    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)));
        }
        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;
        }
Exemple #4
0
    private Color[] CalculateVertexColors(Transform[] bones, Mesh m, Bone bone)
    {
        Color[] colors = new Color[m.vertexCount];

        for (int i = 0; i < colors.Length; i++)
        {
            colors[i] = Color.black;
        }

        if (bones.Any(b => b.gameObject.GetInstanceID() == bone.gameObject.GetInstanceID()))
        {
            for (int i = 0; i < colors.Length; i++)
            {
                float value = 0;

                BoneWeight bw = m.boneWeights[i];
                if (bw.boneIndex0 == boneIndex)
                {
                    value = bw.weight0;
                }
                else if (bw.boneIndex1 == boneIndex)
                {
                    value = bw.weight1;
                }
                else if (bw.boneIndex2 == boneIndex)
                {
                    value = bw.weight2;
                }
                else if (bw.boneIndex3 == boneIndex)
                {
                    value = bw.weight3;
                }

                Util.HSBColor hsbColor = new Util.HSBColor(0.7f - value, 1.0f, 0.5f);
                hsbColor.a = colorTransparency;
                colors[i]  = Util.HSBColor.ToColor(hsbColor);
            }
        }

        return(colors);
    }
        public static HSBColor Lerp(HSBColor a, HSBColor b, float t) {
            float h, s;

            //check special case black (color.b==0): interpolate neither hue nor saturation!
            //check special case grey (color.s==0): don't interpolate hue!
            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 {
                    // works around bug with LerpAngle
                    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));
        }
    private Color[] CalculateVertexColors(Transform[] bones, Mesh m, Bone bone) {
        Color[] colors = new Color[m.vertexCount];

        for (int i = 0; i < colors.Length; i++) {
            colors[i] = Color.black;
        }

        if (bones.Any(b => b.gameObject.GetInstanceID() == bone.gameObject.GetInstanceID())) {
            for (int i = 0; i < colors.Length; i++) {
                float value = 0;

                BoneWeight bw = m.boneWeights[i];
				if (bw.boneIndex0 == boneIndex)
                    value = bw.weight0;
				else if (bw.boneIndex1 == boneIndex)
                    value = bw.weight1;
				else if (bw.boneIndex2 == boneIndex)
                    value = bw.weight2;
				else if (bw.boneIndex3 == boneIndex)
                    value = bw.weight3;

                Util.HSBColor hsbColor = new Util.HSBColor(0.7f - value, 1.0f, 0.5f);
				hsbColor.a = colorTransparency;
				colors[i] = Util.HSBColor.ToColor(hsbColor);
            }
        }

        return colors;
    }