HSBColor

From Unify Community Wiki
Revision as of 14:50, 11 August 2007 by Aarku (Talk | contribs)

Jump to: navigation, search

Author: Jonathan Czeck (aarku)

Description

This script provides a Hue/Saturation/Brightness/Alpha color model in addition to Unity's built in Red/Green/Blue/Alpha colors. It is useful for interpolating between colors in a more pleasing fashion.

Usage

Put this script in a file in /Plugins/HSBColor.cs so that it may be callable by JavaScript. Additionally, there is a helper class called Colorx that is useful to put in your Plugins folder. This provides a quick helper function to slerp between two Colors, which gives much more visually pleasing results than Color.Lerp. See Colorx for a simple importable Unity Package.

C# - HSBColor.cs

<csharp> using UnityEngine;

[System.Serializable] public struct 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)
   {
       // 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;
       
       return new HSBColor(angle / 360f, Mathf.Lerp(a.s, b.s, t), Mathf.Lerp(a.b, b.b, t), Mathf.Lerp(a.a, b.a, t));
   }
   
   public static void Test()
   {
       HSBColor color;
       
       color = new HSBColor(Color.red);
       Debug.Log("red: " + color);
       
       color = new HSBColor(Color.green);
       Debug.Log("green: " + color);
       
       color = new HSBColor(Color.blue);
       Debug.Log("blue: " + color);
       
       color = new HSBColor(Color.grey);
       Debug.Log("grey: " + color);
       
       color = new HSBColor(Color.white);
       Debug.Log("white: " + color);
       
       color = new HSBColor(new Color(0.4f, 1f, 0.84f, 1f));
       Debug.Log("0.4, 1f, 0.84: " + color);
       
       Debug.Log("164,82,84   .... 0.643137f, 0.321568f, 0.329411f  :" + ToColor(new HSBColor(new Color(0.643137f, 0.321568f, 0.329411f))));
   }

} </csharp>

Personal tools
Namespaces

Variants
Actions
Navigation
Extras
Toolbox