public static Color hsv2rgb( ColorHSV c )
{
float hh, p, q, t, ff;
long i;
Color ret = new Color();
ret.a = c.a;
if( c.s <= 0.0f ) { // < is bogus, just shuts up warnings
ret.r = c.v;
ret.g = c.v;
ret.b = c.v;
return ret;
}
hh = c.h;
if(hh >= 360.0f) hh = 0.0f;
hh /= 60.0f;
i = (long)hh;
ff = hh - i;
p = c.v * (1.0f - c.s);
q = c.v * (1.0f - (c.s * ff));
t = c.v * (1.0f - (c.s * (1.0f - ff)));
switch(i) {
case 0:
ret.r = c.v;
ret.g = t;
ret.b = p;
break;
case 1:
ret.r = q;
ret.g = c.v;
ret.b = p;
break;
case 2:
ret.r = p;
ret.g = c.v;
ret.b = t;
break;
case 3:
ret.r = p;
ret.g = q;
ret.b = c.v;
break;
case 4:
ret.r = t;
ret.g = p;
ret.b = c.v;
break;
case 5:
default:
ret.r = c.v;
ret.g = p;
ret.b = q;
break;
}
return ret;
}
// Update is called once per frame
void Update()
{
h += 0.001f;
if (h > 1f) {
h = 0;
}
colorHSV = new ColorHSV(h, colorHSV.s, colorHSV.v);
gameObject.GetComponent<Renderer> ().material.color = colorHSV;
}
public Color RandomColor()
{
var color = new ColorHSV(
Random.Range(0f, 255f),
Random.Range(0.8f, 1f),
Random.Range(0.8f, 1f)
);
return color.ToColor();
}
public static Color PlanetColor()
{
float h = Random.Range(0f, 360f);
float s = Random.Range(0.5f, 0.9f);
float v = Random.Range(0.9f, 1.0f);
float a = 1f;
var color = new ColorHSV(h, s, v, a);
return color.ToColor();
}
public static Color RainbowColor()
{
float h = Random.Range(0f, 360f);
float s = Random.Range(0.3f, 0.7f);
float v = Random.Range(0.9f, 1.0f);
float a = 0.7f;
var color = new ColorHSV(h, s, v, a);
return color.ToColor();
}
// Update is called once per frame
void Update()
{
s += 0.001f;
if (s > 1f) {
s = 0;
}
colorHSV = new ColorHSV(colorHSV.h, s, colorHSV.v);
gameObject.GetComponent<Renderer> ().material.color = colorHSV;
}
// Update is called once per frame
void Update()
{
v += 0.001f;
if (v > 1f) {
v = 0;
}
colorHSV = new ColorHSV(colorHSV.h, colorHSV.s, v);
gameObject.GetComponent<Renderer> ().material.color = colorHSV;
}
public Color RandomNeutralColor()
{
var lightGreen = new ColorHSV(132f, 0.8f, 1.0f).ToColor();
var lime = new ColorHSV(0.95f, 0.866f, 1.0f).ToColor();
var neutrals = new List<Color>()
{
lightGreen, lime
};
var neutralColor = neutrals.Random();
return neutralColor;
}
public Gradient BlendGradient(Gradient terrain_gradient, Gradient object_gradient)
{
List<ColorHSV> targetPalette = new List<ColorHSV>();
List<ColorHSV> currentPalette = new List<ColorHSV>();
targetPalette = RandomE.TetradicPalette(0.25f, 0.75f);
Debug.Log(targetPalette.Count);
ColorHSV groundColor = new ColorHSV(terrain_gradient.Evaluate(0));
ColorHSV newColor = new ColorHSV(object_gradient.Evaluate(1));
targetPalette.Add(ColorHSV.Lerp(groundColor, newColor, 0.5f));
var gradient = ColorE.Gradient(from: targetPalette[2].WithSV(0.8f, 0.8f),
to: targetPalette[3].WithSV(0.8f, 0.8f));
return object_gradient;
}
void Awake()
{
if (!useDefinedPosition)
{
positionLeft = (Screen.width / 2) - (textureWidth / 2);
positionTop = (Screen.height / 2) - (textureHeight / 2);
}
// if a default color picker texture hasn't been assigned, make one dynamically
if (!colorPicker)
{
colorPicker = new Texture2D(textureWidth, textureHeight, TextureFormat.ARGB32, false);
ColorHSV hsvColor;
for (int i = 0; i < textureWidth; i++)
{
for (int j = 0; j < textureHeight; j++)
{
hsvColor = new ColorHSV((float)i, 1.0f, 1.0f);
colorPicker.SetPixel(i, j, hsvColor.ToColor());
}
}
}
colorPicker.Apply();
displayPicker = colorPicker;
if (!useDefinedSize)
{
textureWidth = colorPicker.width;
textureHeight = colorPicker.height;
}
float v = 0.0F;
float diff = 1.0f / (textureHeight * 2.0f);
saturationTexture = new Texture2D(20, textureHeight * 2);
for (int i = 0; i < saturationTexture.width; i++)
{
for (int j = 0; j < saturationTexture.height; j++)
{
saturationTexture.SetPixel(i, j, new Color(v, v, v));
v += diff;
}
v = 0.0F;
}
saturationTexture.Apply();
// small color picker box texture
styleTexture = new Texture2D(1, 1);
styleTexture.SetPixel(0, 0, setColor);
}
private void GenerateLevel()
{
// Destroy existing bricks
foreach (var brick in bricks)
{
Object.Destroy(brick);
}
bricks.Clear();
float fromHue = Random.value;
float toHue = fromHue + 30 / 360f;
var backgroundColor = new ColorHSV(fromHue, backgroundColorSaturation, backgroundColorValue).complementary;
mainCamera.backgroundColor = backgroundColor.ToColor();
for (int y = 0; y < config.wallHeight; y++)
{
// Select color for current line
float hue = Mathf.Lerp(fromHue, toHue, y / (config.wallHeight - 1f));
// Generate brick sizes for current line
List <BrickSize> brickSizes = FillWallWithBricks(config.wallWidth);
Vector3 leftEdge = Vector3.left * config.wallWidth / 2 +
Vector3.up * (config.wallHeightOffset + y * brickHeight);
for (int i = 0; i < brickSizes.Count; i++)
{
var brickSize = brickSizes[i];
var position = leftEdge + Vector3.right * sizeValues[brickSize] / 2;
// Randomize tint of current brick
float colorValue = Random.Range(brickColorMinValue, brickColorMaxValue);
Color color = new ColorHSV(hue, brickColorSaturation, colorValue).ToColor();
bricks.Add(GenerateBrick(position, color, brickSize));
leftEdge.x += sizeValues[brickSize];
}
}
}
public static ColorRYB HSVtoRYB(ColorHSV hsv)
{
float r = 0, y = 0, b = 0, h = hsv.h * 360, s = hsv.s, v = hsv.v;
float c = v * s;
float x = c * (1 - Mathf.Abs((((h) / (60)) % 2) - 1));
float m = v - c;
if (h >= 0 && h < 60)
{
r = c;
y = x;
}
else if (h >= 60 && h < 120)
{
r = x;
y = c;
}
else if (h >= 120 && h < 180)
{
y = c;
b = x;
}
else if (h >= 180 && h < 240)
{
y = x;
b = c;
}
else if (h >= 240 && h < 300)
{
r = x;
b = c;
}
else if (h >= 300 && h < 360)
{
r = c;
b = x;
}
return(new ColorRYB(r + m, y + m, b + m));
}
private ColorHSV RGBToHSV(Color32 inColor)
{
_hsvColor = new ColorHSV();
float min = Mathf.Min(Mathf.Min(inColor.r, inColor.g), inColor.b);
float max = Mathf.Max(Mathf.Max(inColor.r, inColor.g), inColor.b);
float chroma = max - min;
//If Chroma is 0, then S is 0 by definition, and H is undefined but 0 by convention.
if (chroma != 0.0f)
{
if (inColor.r == max)
{
_hsvColor.hue = (inColor.g - inColor.b) / chroma;
if (_hsvColor.hue < 0.0f)
{
_hsvColor.hue += 6.0f;
}
}
else if (inColor.g == max)
{
_hsvColor.hue = ((inColor.b - inColor.r) / chroma) + 2.0f;
}
else
{
_hsvColor.hue = ((inColor.r - inColor.g) / chroma) + 4.0f;
}
_hsvColor.hue *= 60.0f;
_hsvColor.saturation = Mathf.RoundToInt(chroma / max * 100.0f);
}
_hsvColor.value = Mathf.RoundToInt(max / 255.0f * 100.0f);
//Debug.Log("Hue: "+ hsvColor.hue + " / Sat: " + hsvColor.saturation + "% / Val: " + hsvColor.value + "%");
return(_hsvColor);
}
public void Update()
{
if (!currentHSVColor.Equals(prevHSVColor))
{
Debug.Log($"hsv change to {currentHSVColor} ,{currentHSVColor.ToRGB()}");
colorField = TextureUtils.GenerateColorField(colorFieldSize, colorFieldSize, currentHSVColor);
prevHSVColor = currentHSVColor;
currentRGBColor = currentHSVColor.ToRGB();
}
if (!currentRGBColor.Equals(prevRGBColor))
{
GenerateTextures();
currentHSVColor = new ColorHSV(currentRGBColor);
// currentHSVColor = new HSBColor(currentRGBColor);
// hueValue = currentHSVColor.h;
// colorField = MaterialUtils.GenerateColorField(colorFieldSize, colorFieldSize, currentHSVColor.ToColor());
prevRGBColor = currentRGBColor;
hueValue = currentHSVColor.h;
}
}
private void DrawEdge(Edge edge)
{
int x, y, width, height;
if (edge.origin.direction == Directions.Left || edge.origin.direction == Directions.Down)
{
x = Translate(edge.exit.x);
y = Translate(edge.exit.y);
}
else
{
x = Translate(edge.origin.x);
y = Translate(edge.origin.y);
}
if (edge.origin.direction == Directions.Left || edge.origin.direction == Directions.Right)
{
width = cellSize * 2 + wallSize;
height = cellSize;
}
else
{
width = cellSize;
height = cellSize * 2 + wallSize;
}
Color color;
if (useGradient)
{
float gradient = Mathf.Abs((Mathf.Repeat(edge.origin.depth / gradientLength, 1) - 0.5f) * 2);
color = new ColorHSV(hue, gradient, gradient).ToColor();
}
else
{
color = Color.white;
}
texture.DrawRect(x, y, width, height, color);
}
public void Init(int id, FlowWindow.Flags flags = Flags.Default)
{
this.states = new CompletedState[STATES_COUNT];
this.tags = new List <int>();
this.id = id;
this.flags = flags;
//this.attaches = new List<int>();
this.attachItems = new List <AttachItem>();
this.attachedComponents = new List <ComponentLink>();
this.rect = new Rect(0f, 0f, 200f, 200f); //new Rect(Screen.width * 0.5f, Screen.height * 0.5f, 200f, 200f);
this.title = (this.IsContainer() == true ? "Container" : "Window " + this.id.ToString());
this.directory = (this.IsContainer() == true ? "ContainerDirectory" : "Window" + this.id.ToString() + "Directory");
this.randomColor = ColorHSV.GetDistinctColor();
this.smallStyleDefault = "flow node 4";
this.smallStyleSelected = "flow node 4 on";
this.compiled = false;
}
private void GenerateLevel()
{
// Return all active bricks to the pool
foreach (var brick in activeBricks)
{
ReturnBrickToPool(brick);
}
activeBricks.Clear();
for (int y = 0; y < config.wallHeight; y++)
{
// Select a color for the current line
var currentColor = new ColorHSV(config.gradient.Evaluate(y / (config.wallHeight - 1f)));
// Generate brick sizes for the current line
List <BrickSize> brickSizes = FillWallWithBricks(config.wallWidth);
Vector3 leftEdge = Vector3.left * config.wallWidth / 2 +
Vector3.up * (config.wallHeightOffset + y * brickHeight);
for (int i = 0; i < brickSizes.Count; i++)
{
var brickSize = brickSizes[i];
var position = leftEdge + Vector3.right * sizeValues[brickSize] / 2;
// Randomize the tint of the current brick
float colorValue = Random.Range(brickColorMinValue, brickColorMaxValue);
Color color = currentColor.WithV(colorValue).ToColor();
var brick = GetBrick();
brick.transform.position = position;
brick.transform.localScale = new Vector3(sizeValues[brickSize], brickHeight);
brick.spriteRenderer.color = color;
activeBricks.Add(brick);
leftEdge.x += sizeValues[brickSize];
}
}
}
// Update is called once per frame
void Update()
{
if (timer > beat)
{
voltm.orbitalZ = orbitalZ;
voltm.orbitalX = orbitalX;
voltm.orbitalOffsetZ = offsetZ;
timer -= beat;
}
else
{
voltm.orbitalZ = 2;
voltm.orbitalX = orbitalX;
voltm.orbitalOffsetZ = offsetZ;
}
timer += Time.deltaTime;
colorr.mode = ParticleSystemGradientMode.TwoColors;
colorr.colorMin = ColorHSV.FromHsv(color_one, 100, 255);
colorr.colorMax = ColorHSV.FromHsv(color_two, 100, 255);
mainEmo.startColor = colorr;
if (RandomColor == true)
{
colorr.colorMin = ColorHSV.FromHsv(Random.Range(0, 360), 200, 255);
colorr.colorMax = ColorHSV.FromHsv(Random.Range(0, 360), 200, 255);
mainEmo.startColor = colorr;
}
if (AutoSwitch == true)
{
AutoChenge();
}
}
// Update is called once per frame
void Update()
{
mainEmo1.startSize = (input * 3) + Emo1_Start_Size;
mainEmo2.startSize = (input * 3) + Emo1_Start_Size;
mainEmo3.startSize = (input * 4) + Emo2_Start_Size;
mainEmo4.startSize = (input * 4) + Emo2_Start_Size;
mainEmo1.startColor = ColorHSV.FromHsv(color_one, 200, 255);
mainEmo2.startColor = ColorHSV.FromHsv(color_one, 200, 255);
mainEmo3.startColor = ColorHSV.FromHsv(color_two, 200, 255);
mainEmo4.startColor = ColorHSV.FromHsv(color_two, 200, 255);
mainEmo5.startColor = ColorHSV.FromHsv(color_three, 200, 255);
if (RandomColor == true)
{
mainEmo1.startColor = ColorHSV.FromHsv(Random.Range(0, 360), 200, 255);
mainEmo2.startColor = ColorHSV.FromHsv(Random.Range(0, 360), 200, 255);
mainEmo3.startColor = ColorHSV.FromHsv(Random.Range(0, 360), 200, 255);
mainEmo4.startColor = ColorHSV.FromHsv(Random.Range(0, 360), 200, 255);
mainEmo5.startColor = ColorHSV.FromHsv(Random.Range(0, 360), 200, 255);
}
}
void Update()
{
if (!gameState.IsPlayingGame)
{
return;
}
ColorHSV hsv = new ColorHSV(Color.Lerp(m_currentColor, m_targetColor, t));
hsv.a = 0.5f;
tweenImage.color = hsv.ToColor();
if (t < 1)
{
t += Time.deltaTime / 8.0f;
}
else if (t >= 1)
{
t = 0f;
m_currentColor = m_targetColor;
m_targetColor = SetNewColor();
}
}
private void OnColorChanged(Color rgb, ColorHSV hsv)
{
if (!(bool)_inputRGB.Tag)
{
_inputRGB.Text = string.Format("{0},{1},{2}", rgb.R, rgb.G, rgb.B);
}
if (!(bool)_inputHSV.Tag)
{
_inputHSV.Text = string.Format("{0},{1},{2}", hsv.H, hsv.S, hsv.V);
}
if (!(bool)_inputHEX.Tag)
{
_inputHEX.Text = rgb.ToHexString().Substring(1, 6);
}
if (!(bool)_inputAlpha.Tag)
{
_inputAlpha.Text = DisplayAlpha.ToString();
}
if (!(bool)_sliderAlpha.Tag)
{
_sliderAlpha.Value = DisplayAlpha;
}
if (!(bool)_hsPicker.Tag)
{
_hsPicker.Top = (int)(hsv.S / 200f * WheelHeight * Math.Sin(DegToRad * (-hsv.H + 180)));
_hsPicker.Left = (int)(hsv.S / 200f * WheelHeight * Math.Cos(DegToRad * (-hsv.H + 180)));
}
if (!(bool)_vPicker.Tag)
{
_vPicker.Top = (int)(hsv.V / -100f * WheelHeight) + WheelHeight;
}
_colorWheel.Color = new Color(hsv.V / 100f, hsv.V / 100f, hsv.V / 100f);
_colorDisplay.Color = rgb;
colorHSV = hsv;
}
/// <summary>
/// Make a gradient between two colors using HSV (Returns a list of colors blended from startColor to endColor).
/// </summary>
/// <returns>A list of colors blended from startColor to endColor.</returns>
/// <param name="startColor">Start color.</param>
/// <param name="endColor">End color.</param>
/// <param name="blendColors>Number of blended colors in the middle (returned list's length will be this value plus two).</param>
public static List <Color> MakeGradientHSV(Color startColor, Color endColor, int blendColors)
{
List <Color> gradient = new List <Color>();
float startHue = startColor.ToHSV().h;
float endHue = endColor.ToHSV().h;
float startSat = startColor.ToHSV().s;
float endSat = endColor.ToHSV().s;
float startVal = startColor.ToHSV().v;
float endVal = endColor.ToHSV().v;
float degreesPerStep = (endHue - startHue);
if (degreesPerStep > 180f)
{
degreesPerStep = degreesPerStep - 360f;
}
if (degreesPerStep < -180f)
{
degreesPerStep = degreesPerStep + 360f;
}
float saturationPerStep = (endSat - startSat);
float valuePerStep = (endVal - startVal);
degreesPerStep /= (float)(blendColors + 1);
saturationPerStep /= (float)(blendColors + 1);
valuePerStep /= (float)(blendColors + 1);
gradient.Add(startColor);
ColorHSV colorHSV = startColor.ToHSV();
for (int i = 0; i < blendColors; i++)
{
colorHSV.ShiftHue(degreesPerStep);
colorHSV.s += saturationPerStep;
colorHSV.v += valuePerStep;
gradient.Add(colorHSV.ToColor());
}
gradient.Add(endColor);
return(gradient);
}
/// <summary>
/// Update the color surface brush according to the current <see cref="Hue"/> value.
/// </summary>
private void RenderColorPickerSurface()
{
if (colorPreviewRenderSurface != null)
{
colorPreviewRenderSurface.Fill = new SolidColorBrush(Color.ToSystemColor());
}
if (colorPickerRenderSurface != null)
{
// Ensure the color picker is loaded
if (!double.IsNaN(colorPickerRenderSurface.Width) && !double.IsNaN(colorPickerRenderSurface.Height))
{
var width = (int)colorPickerRenderSurface.Width;
var height = (int)colorPickerRenderSurface.Height;
PixelFormat pf = PixelFormats.Bgr32;
int rawStride = (width * pf.BitsPerPixel + 7) / 8;
var rawImage = new byte[rawStride * height];
for (int j = 0; j < height; ++j)
{
float y = j / (float)(height - 1);
for (int i = 0; i < width; ++i)
{
float x = i / (float)(width - 1);
var color4 = new ColorHSV(Hue, x, y, 1.0f).ToColor();
var color = new Color(color4);
rawImage[(i + j * width) * 4 + 0] = color.B;
rawImage[(i + j * width) * 4 + 1] = color.G;
rawImage[(i + j * width) * 4 + 2] = color.R;
}
}
colorPickerRenderSurface.Fill = new DrawingBrush(new ImageDrawing(BitmapSource.Create(width, height, 96, 96, pf, null, rawImage, rawStride), new Rect(0.0f, 0.0f, width, height)));
}
}
}
private IEnumerator GenerateCoroutine()
{
var algorithm = generatorAlgorithm;
if (algorithm == MazeGenerator.Algorithm.None)
{
algorithm = RandomE.GetRandom(MazeGenerator.Algorithm.RandomTraversal,
MazeGenerator.Algorithm.RandomDepthFirstTraversal,
MazeGenerator.Algorithm.RandomBreadthFirstTraversal);
}
hue = Random.value;
var backgroundColor = new ColorHSV(hue, backgroundSaturation, backgroundValue).complementary.ToColor();
background.CrossFadeColor(backgroundColor, fadeDuration, true, false);
switch (algorithm)
{
case MazeGenerator.Algorithm.RandomTraversal:
yield return(StartCoroutine(mazeGenerator.RandomTraversal(DrawEdge, texture.Apply)));
break;
case MazeGenerator.Algorithm.RandomDepthFirstTraversal:
yield return(StartCoroutine(mazeGenerator.RandomDepthFirstTraversal(DrawEdge, texture.Apply)));
break;
case MazeGenerator.Algorithm.RandomBreadthFirstTraversal:
yield return(StartCoroutine(mazeGenerator.RandomBreadthFirstTraversal(DrawEdge, texture.Apply)));
break;
}
texture.Apply();
byte[] bytes = texture.EncodeToPNG();
// For testing purposes, also write to a file in the project folder
File.WriteAllBytes(Application.dataPath + "/../SavedScreen.png", bytes);
}
/// <summary>
/// Make a rainbow from the start color, shifting the hue until it reaches the end hue. (Returns a list of Colors).
/// </summary>
/// <param name="startColor">Start color.</param>
/// <param name="endColor">Hue to stop shifting at (will only use the hue of this color, not value or saturation).</param>
/// <param name="length">Desired length of the list.</param>
public static List <Color> Rainbowify(Color startColor, Color endColor, int length)
{
List <Color> rainbow = new List <Color>();
float startHue = startColor.ToHSV().h;
float endHue = endColor.ToHSV().h;
if (endHue < startHue)
{
endHue += 360f;
}
float degreesPerStep = (endHue - startHue);
degreesPerStep /= (float)length - 1;
rainbow.Add(startColor);
ColorHSV colorHSV = startColor.ToHSV();
for (int i = 0; i < length - 1; i++)
{
colorHSV.ShiftHue(degreesPerStep);
rainbow.Add(colorHSV.ToColor());
}
return(rainbow);
}
public static Color LerpHsv(ColorHSV a, ColorHSV b, float t)
{
// Hue interpolation
float h = 0;
float d = b.h - a.h;
if (a.h > b.h)
{
// Swap (a.h, b.h)
var h3 = b.h;
b.h = a.h;
a.h = h3;
d = -d;
t = 1 - t;
}
if (d > 0.5) // 180deg
{
a.h = a.h + 1; // 360deg
h = (a.h + t * (b.h - a.h)) % 1; // 360deg
}
if (d <= 0.5) // 180deg
{
h = a.h + t * d;
}
// Interpolates the rest
return(new ColorHSV
(
h, // H
a.s + t * (b.s - a.s), // S
a.v + t * (b.v - a.v), // V
a.a + t * (b.a - a.a) // A
));
}
public NetworkOutputs(string[] names)
{
this.Size = names.Length;
this.Names = names;
this.DistanceMult = 1.5d / Math.Sqrt(this.Size); // the 1.5 doesn't mean anything. It just helps push them apart a little more
this.Hues = CreateHues(this.Size);
#region Materials
SpecularMaterial specular = new SpecularMaterial(new SolidColorBrush(UtilityWPF.ColorFromHex("50FFFFFF")), 2);
// Colors
this.DotColors = this.Hues.Select(o =>
{
ColorHSV color = new ColorHSV(o, 75, 75);
MaterialGroup material = new MaterialGroup();
material.Children.Add(new DiffuseMaterial(new SolidColorBrush(color.ToRGB())));
material.Children.Add(specular);
return(new Tuple <ColorHSV, Material>(color, material));
}).ToArray();
// Gray
this.ColorGray = new ColorHSV(0, 0, 50);
MaterialGroup material_Gray = new MaterialGroup();
material_Gray.Children.Add(new DiffuseMaterial(new SolidColorBrush(this.ColorGray.ToRGB())));
material_Gray.Children.Add(specular);
this.DotGray = material_Gray;
#endregion
}
public ColorHSV[] GetRandomFlagColors(int count, IEnumerable <ColorHSV> existing = null)
{
if (count > _maxFlagColors)
{
throw new ArgumentOutOfRangeException(string.Format("Can't create that many colors: {0}. Max allowed: {1}", count.ToString(), _maxFlagColors.ToString()));
}
ColorHSV[] retVal = new ColorHSV[count];
var categorized = new List <Tuple <ColorHSV, FlagColorCategory> >();
GetRandomFlagColors_LoadExisting(existing, retVal, categorized);
int index = categorized.Count;
for (int cntr = 0; cntr < count; cntr++)
{
var color = GetRandomFlagColors_Next(categorized);
retVal[cntr] = color.Item1;
categorized.Add(color);
}
return(retVal);
}
void Start()
{
webcam = GameObject.FindObjectOfType <Webcam>();
shouldDrawGrid = textMesh.GetComponent <Renderer>().enabled;
Shader.SetGlobalFloat("_LightRatio", textMesh.GetComponent <Renderer>().enabled ? 0.5f : 1f);
SetColor(Color.white);
materialGrid = new Material(Shader.Find("Hidden/Line"));
messageMeshSize = messageMesh.characterSize;
messageMesh.characterSize = 0f;
currentMessage = 0;
currentScore = 0;
watchOutScale = watchOutMesh.transform.localScale.x;
watchOutMesh.transform.localScale = Vector3.zero;
textSize = scoreMesh.characterSize;
textColor = Color.white;
textColorNext = ColorHSV.GetRandomColor();
colorAlpha = new Color(1f, 1f, 1f, 0f);
UpdateText();
}
internal static void UpdateElectroLights(AuroraManager mngr)
{
for (int e = 0; e < electroSources.Count; e++)
{
if (electroSources[e].electrolizer != null && electroSources[e].electrolizer.m_LocalLights != null)
{
for (int i = 0; i < electroSources[e].electrolizer.m_LocalLights.Length; i++)
{
float cur_range = electroSources[e].ranges[i];
cur_range *= Settings.options.rangeMultiplier;
cur_range = Math.Min(cur_range, 20f);
electroSources[e].electrolizer.m_LocalLights[i].range = cur_range;
ColorHSV curColor = electroSources[e].colors[i];
if (Settings.options.whiteLights)
{
curColor.s *= 0.15f;
}
electroSources[e].electrolizer.m_LocalLights[i].color = curColor;
if (Settings.options.castShadows)
{
electroSources[e].electrolizer.m_LocalLights[i].shadows = LightShadows.Soft;
}
}
if (lightsOn && !mngr.AuroraIsActive())
{
if (!electroSources[e].electrolizer.gameObject.name.Contains("Alarm") &&
!electroSources[e].electrolizer.gameObject.name.Contains("Headlight") &&
!electroSources[e].electrolizer.gameObject.name.Contains("Taillight") &&
!electroSources[e].electrolizer.gameObject.name.Contains("Television") &&
!electroSources[e].electrolizer.gameObject.name.Contains("Computer") &&
!electroSources[e].electrolizer.gameObject.name.Contains("Machine") &&
!electroSources[e].electrolizer.gameObject.name.Contains("ControlBox") &&
!electroSources[e].electrolizer.gameObject.name.Contains("Interiorlight"))
{
electroSources[e].electrolizer.m_CurIntensity = Settings.options.intensityValue;
electroSources[e].electrolizer.UpdateLight(false);
electroSources[e].electrolizer.UpdateFX(false);
electroSources[e].electrolizer.UpdateEmissiveObjects(false);
electroSources[e].electrolizer.StopAudio();
}
}
else if (!mngr.AuroraIsActive())
{
electroSources[e].electrolizer.m_CurIntensity = 0f;
electroSources[e].electrolizer.UpdateLight(true);
electroSources[e].electrolizer.UpdateFX(true);
electroSources[e].electrolizer.UpdateEmissiveObjects(true);
electroSources[e].electrolizer.UpdateAudio();
}
else
{
electroSources[e].electrolizer.UpdateIntensity(Time.deltaTime, true);
}
}
}
for (int e = 0; e < electroLightSources.Count; e++)
{
if (electroLightSources[e].electrolizer != null && electroLightSources[e].electrolizer.m_LocalLights != null)
{
for (int i = 0; i < electroLightSources[e].electrolizer.m_LocalLights.Length; i++)
{
float cur_range = electroLightSources[e].ranges[i];
cur_range *= Settings.options.rangeMultiplier;
cur_range = Math.Min(cur_range, 20f);
electroLightSources[e].electrolizer.m_LocalLights[i].range = cur_range;
ColorHSV curColor = electroLightSources[e].colors[i];
if (Settings.options.whiteLights)
{
curColor.s *= 0.15f;
}
electroLightSources[e].electrolizer.m_LocalLights[i].color = curColor;
if (Settings.options.castShadows)
{
electroLightSources[e].electrolizer.m_LocalLights[i].shadows = LightShadows.Soft;
}
}
if (lightsOn && !mngr.AuroraIsActive())
{
if (!electroLightSources[e].electrolizer.gameObject.name.Contains("Alarm") &&
!electroLightSources[e].electrolizer.gameObject.name.Contains("Headlight") &&
!electroLightSources[e].electrolizer.gameObject.name.Contains("Taillight") &&
!electroLightSources[e].electrolizer.gameObject.name.Contains("Television") &&
!electroLightSources[e].electrolizer.gameObject.name.Contains("Computer") &&
!electroLightSources[e].electrolizer.gameObject.name.Contains("Machine") &&
!electroLightSources[e].electrolizer.gameObject.name.Contains("ControlBox") &&
!electroLightSources[e].electrolizer.gameObject.name.Contains("Interiorlight"))
{
electroLightSources[e].electrolizer.m_CurIntensity = Settings.options.intensityValue;
electroLightSources[e].electrolizer.UpdateLight(false);
electroLightSources[e].electrolizer.UpdateEmissiveObjects(false);
electroLightSources[e].electrolizer.StopAudio();
}
}
else if (!mngr.AuroraIsActive())
{
electroLightSources[e].electrolizer.m_CurIntensity = 0f;
electroLightSources[e].electrolizer.UpdateLight(true);
electroLightSources[e].electrolizer.UpdateEmissiveObjects(true);
electroLightSources[e].electrolizer.UpdateAudio();
}
else
{
electroLightSources[e].electrolizer.UpdateIntensity(Time.deltaTime);
}
}
}
}
private void UpdateColourPicker()
{
ColorHSV hsvColor;
for (int i = 0; i < textureWidth; i++)
{
for (int j = 0; j < textureHeight; j++)
{
hsvColor = new ColorHSV((float)i, (1.0f / j) * textureHeight, saturationSlider);
_colorPicker.SetPixel(i, j, hsvColor.ToColor());
}
}
_colorPicker.Apply();
displayPicker = _colorPicker;
displayPicker.Apply();
}
private void SetColor(ColorHSV color)
{
CurrentColor = color;
CurrentColorBrush = color.ToBrush();
}
public static Color GetColor (float h, float s, float v)
{
ColorHSV col = new ColorHSV(h, s, v);
return col.ToColor();
}
//-----------------------------------------------------
public static Color SetValueTo(Color col, float newValue)
{
ColorHSV hsv = new ColorHSV(col);
hsv.SetV(newValue);
return hsv.ToColor();
}
//-----------------------------------------------------
public static float GetValue(Color col)
{
ColorHSV hsv = new ColorHSV(col);
return hsv.GetV();
}
// distance in RGB space
int ColorDiff(ColorHSV c1, ColorHSV c2)
{
return((int)Math.Sqrt((c1.r - c2.r) * (c1.r - c2.r)
+ (c1.g - c2.g) * (c1.g - c2.g)
+ (c1.b - c2.b) * (c1.b - c2.b)));
}
/// <summary>
/// Raised when the <see cref="Hue"/>, <see cref="Saturation"/>, or <see cref="Brightness"/> properties are modified.
/// </summary>
/// <param name="e">The dependency property that has changed.</param>
private void OnHSVValueChanged(DependencyPropertyChangedEventArgs e)
{
bool isInitializing = !templateApplied && initializingProperty == null;
if (isInitializing)
initializingProperty = e.Property;
if (!interlock)
{
if (e.Property == HueProperty)
{
InternalColor = new ColorHSV((float)e.NewValue, Saturation / 100.0f, Brightness / 100.0f, Alpha / 255.0f);
RenderColorPickerSurface();
}
else if (e.Property == SaturationProperty)
InternalColor = new ColorHSV(Hue, (float)e.NewValue / 100.0f, Brightness / 100.0f, Alpha / 255.0f);
else if (e.Property == BrightnessProperty)
InternalColor = new ColorHSV(Hue, Saturation / 100.0f, (float)e.NewValue / 100.0f, Alpha / 255.0f);
else
throw new ArgumentException("Property unsupported by method OnHSVValueChanged.");
var colorRGBA = InternalColor.ToColor();
interlock = true;
SetCurrentValue(RedProperty, (byte)(Math.Round(colorRGBA.R * 255.0f)));
SetCurrentValue(GreenProperty, (byte)(Math.Round(colorRGBA.G * 255.0f)));
SetCurrentValue(BlueProperty, (byte)(Math.Round(colorRGBA.B * 255.0f)));
SetCurrentValue(AlphaProperty, (byte)(Math.Round(colorRGBA.A * 255.0f)));
interlock = false;
}
UpdateBinding(e.Property);
if (colorPickerSelector != null && colorPickerRenderSurface != null && !suspendBindingUpdates)
{
Canvas.SetLeft(colorPickerSelector, Saturation * colorPickerRenderSurface.Width / 100.0);
Canvas.SetTop(colorPickerSelector, Brightness * colorPickerRenderSurface.Height / 100.0);
}
if (huePickerSelector != null && huePickerRenderSurface != null && !suspendBindingUpdates)
{
Canvas.SetLeft(huePickerSelector, Hue * huePickerRenderSurface.Width / 360.0);
}
if (isInitializing)
initializingProperty = null;
}
/// <summary>
/// Creates a gradient between two colors
/// </summary>
public static Gradient Gradient(ColorHSV from, ColorHSV to)
{
var g = new Gradient();
g.SetKeys(new[] {new GradientColorKey(from.ToColor(), 0), new GradientColorKey(to.ToColor(), 1)},
new[] {new GradientAlphaKey(from.a, 0), new GradientAlphaKey(to.a, 1)});
return g;
}
public static Color GetRandomColor(float h ,float s ,float v)
{
ColorHSV col = new ColorHSV(h,s,v);
return col.ToColor();
}
public ColorHSVAmount(ColorHSVAmount cHSVA)
{
colorHSV = cHSVA.colorHSV;
amount = cHSVA.amount;
}
/// <summary>
/// Initializes a new instance of the ColorHSVAmount class.
/// </summary>
/// <param name="c">Color (in HSV).</param>
/// <param name="a">Amount (should be between 0.0f and 1.0f).</param>
public ColorHSVAmount(ColorHSV c, float a)
{
colorHSV = c;
amount = a;
}
public ColorHSV(ColorHSV cHSV)
{
h = cHSV.h;
s = cHSV.s;
v = cHSV.v;
a = cHSV.a;
}
public static Color HSVtoRGB(ColorHSV color)
{
float r = 0;
float g = 0;
float b = 0;
int i = Mathf.FloorToInt(color.h * 6f);
float f = color.h * 6f - i;
float p = color.v * (1f - color.s);
float q = color.v * (1f - f * color.s);
float t = color.v * (1f - (1f - f) * color.s);
switch (i % 6) {
case 0:
r = color.v;
g = t;
b = p;
break;
case 1:
r = q;
g = color.v;
b = p;
break;
case 2:
r = p;
g = color.v;
b = t;
break;
case 3:
r = p;
g = q;
b = color.v;
break;
case 4:
r = t;
g = p;
b = color.v;
break;
case 5:
r = color.v;
g = p;
b = q;
break;
default: break;
}
return new Color(r, g, b);
}
// closed match in RGB space
Color32 ClosestColorRGB(ColorHSV[] colors, ColorHSV target)
{
var colorDiffs = colors.Select(n => ColorDiff(n, target)).Min(n => n);
return(colors.ToList().Find(n => ColorDiff(n, target) == colorDiffs).color);
}
// weighed only by saturation and brightness
float ColorNum(ColorHSV c)
{
return(c.s + getBrightness(c.color));
}
/// <summary>
/// Raised when the <see cref="Red"/>, <see cref="Green"/>, <see cref="Blue"/> or <see cref="Alpha"/> properties are modified.
/// </summary>
/// <param name="e">The dependency property that has changed.</param>
private void OnRGBAValueChanged(DependencyPropertyChangedEventArgs e)
{
bool isInitializing = !templateApplied && initializingProperty == null;
if (isInitializing)
initializingProperty = e.Property;
if (!interlock)
{
Color4 colorRGBA;
if (e.Property == RedProperty)
colorRGBA = new Color4((byte)e.NewValue / 255.0f, Green / 255.0f, Blue / 255.0f, Alpha / 255.0f);
else if (e.Property == GreenProperty)
colorRGBA = new Color4(Red / 255.0f, (byte)e.NewValue / 255.0f, Blue / 255.0f, Alpha / 255.0f);
else if (e.Property == BlueProperty)
colorRGBA = new Color4(Red / 255.0f, Green / 255.0f, (byte)e.NewValue / 255.0f, Alpha / 255.0f);
else if (e.Property == AlphaProperty)
colorRGBA = new Color4(Red / 255.0f, Green / 255.0f, Blue / 255.0f, (byte)e.NewValue / 255.0f);
else
throw new ArgumentException("Property unsupported by method OnRGBAValueChanged.");
interlock = true;
InternalColor = ColorHSV.FromColor(colorRGBA);
SetCurrentValue(HueProperty, InternalColor.H);
SetCurrentValue(SaturationProperty, InternalColor.S * 100.0f);
SetCurrentValue(BrightnessProperty, InternalColor.V * 100.0f);
interlock = false;
}
UpdateBinding(e.Property);
if (isInitializing)
initializingProperty = null;
}
//-----------------------------------------------------
public static Color Desaturate(Color col, float stren)
{
ColorHSV hsv = new ColorHSV(col);
hsv.SetS(hsv.GetS() - (hsv.GetS()*stren));
return hsv.ToColor();
}
public Color RandomLightColor()
{
var white = new ColorHSV(0f, 0f, 1.0f).ToColor();
var lightColor = white;
return lightColor;
}
//-----------------------------------------------------
public static Color LowerValue(Color col, float stren)
{
ColorHSV hsv = new ColorHSV(col);
hsv.SetV(hsv.GetV() - (hsv.GetV()*stren));
return hsv.ToColor();
}
public Color RandomDarkColor()
{
var darkPurple = new ColorHSV(277f, 1.0f, 0.266f).ToColor();
var darkColor = darkPurple;
return darkColor;
}
// Use this for initialization
void Start()
{
col = new ColorHSV {A = 100.0f, H = Random.value * 360.0f, S = Random.value * 100.0f, V = Random.value * 100.0f};
syst = GetComponent<TCParticleSystem>();
syst.ParticleRenderer.Material.SetColor("_TintColor", col.ToColor());
}
private static Visual3D TestSamples_Draw(SketchSample[] sketches, double[] hues)
{
const double RADIUS = .5;
const double DOTRADIUS = .035;
#region Materials
SpecularMaterial specular = new SpecularMaterial(new SolidColorBrush(UtilityWPF.ColorFromHex("50FFFFFF")), 2);
var material_Color = hues.Select(o =>
{
ColorHSV color = new ColorHSV(o, 75, 75);
MaterialGroup material = new MaterialGroup();
material.Children.Add(new DiffuseMaterial(new SolidColorBrush(color.ToRGB())));
material.Children.Add(specular);
return(new { Color = color, Material = material });
}).ToArray();
ColorHSV color_Gray = new ColorHSV(0, 0, 50);
MaterialGroup material_Gray = new MaterialGroup();
material_Gray.Children.Add(new DiffuseMaterial(new SolidColorBrush(color_Gray.ToRGB())));
material_Gray.Children.Add(specular);
#endregion
Model3DGroup group = new Model3DGroup();
foreach (SketchSample sketch in sketches)
{
int?matchIndex = UtilityEncog.IsMatch(sketch.NNOutput);
Material material;
if (matchIndex == null)
{
sketch.IsMatch = false;
sketch.Color = color_Gray;
material = material_Gray;
}
else
{
sketch.IsMatch = true;
sketch.Color = material_Color[matchIndex.Value].Color;
material = material_Color[matchIndex.Value].Material;
}
sketch.Position = Math3D.GetRandomVector_Spherical(RADIUS).ToPoint();
sketch.Translate_3DDot = new TranslateTransform3D(sketch.Position.ToVector());
// Geometry Model
GeometryModel3D geometry = new GeometryModel3D();
geometry.Material = material;
geometry.BackMaterial = material;
geometry.Geometry = UtilityWPF.GetSphere_Ico(DOTRADIUS, 1, true);
geometry.Transform = sketch.Translate_3DDot;
group.Children.Add(geometry);
}
ModelVisual3D visual = new ModelVisual3D();
visual.Content = group;
return(visual);
}
public static Color GetRandomColor ()
{
ColorHSV col = new ColorHSV(Random.Range(0.0f, 360f), 1f, 1f);
return col.ToColor();
}
public static SystemColor ToSystemColor(this ColorHSV color)
{
return(ToSystemColor(color.ToColor()));
}
public static void SetHSV( ref Color c, ColorHSV hsv )
{
c = hsv2rgb( hsv );
}
public static List<Color> RandomColors(int size)
{
ColorHSV _c = new ColorHSV(0, 1, 1);
List <Color> colors = new List <Color> ();
int colorsDet = Mathf.RoundToInt (360 / size);
for (int i = 0; i < size; i++) {
_c.h += colorsDet;
colors.Add(HSVtoRGB(_c));
Debug.Log(HSVtoRGB(_c));
}
return colors;
}
private void rectOriginalColor_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
ColorHsv = new ColorHSV(OriginalBrush.Color);
UpdateColor();
}
/// <summary>
/// Sets the color.
/// </summary>
/// <param name="color">Color.</param>
public void SetColor(ColorHSV color)
{
currentColor = color;
UpdateView();
}
public void Generate()
{
//縦方向のピクセル数
int size = Mathf.CeilToInt((float)heightMap.width / pixelSampleRate);
//pixelSampleRateごとにheightMapのピクセルの色を取得
Color[] pixels = new Color[size * size];
int p = 0;
for (int z = 0; z < size * pixelSampleRate; z += pixelSampleRate)
{
for (int x = 0; x < size * pixelSampleRate; x += pixelSampleRate)
{
pixels[p] = heightMap.GetPixel(x, z);
p++;
}
}
//ピクセルの色から頂点の座標とUV座標を設定
Vector3[] vertices = new Vector3[size * size];
Vector2[] uvs = new Vector2[size * size];
p = 0;
for (int z = 0; z < size; z++)
{
for (int x = 0; x < size; x++)
{
ColorHSV colorHSV = ColorUtility.GetHSVByRGB(pixels[p]);
float y = colorHSV.v * heightMultiplier;
float random = Random.Range(-noise, noise);
vertices[z * size + x] = new Vector3(x * sizeMultiplier * pixelSampleRate, y, z * sizeMultiplier * pixelSampleRate) + new Vector3(1f, 0, 1f) * random;
uvs[z * size + x] = new Vector2(vertices[z * size + x].x / size, vertices[z * size + x].z / size) / (pixelSampleRate * sizeMultiplier);
p++;
}
}
//頂点インデックスの設定
/*
* a ← b
*
* ↓ ↗︎↙︎ ↑
*
* c → d
*
*/
int triangleIndex = 0;
int[] triangles = new int[(size - 1) * (size - 1) * 6];
for (int z = 0; z < size - 1; z++)
{
for (int x = 0; x < size - 1; x++)
{
int a = z * size + x;
int b = a + 1;
int c = a + size;
int d = c + 1;
triangles[triangleIndex] = a;
triangles[triangleIndex + 1] = c;
triangles[triangleIndex + 2] = b;
triangles[triangleIndex + 3] = c;
triangles[triangleIndex + 4] = d;
triangles[triangleIndex + 5] = b;
triangleIndex += 6;
}
}
//頂点座標、UV座標、頂点インデックスから、メッシュを生成
Mesh mesh = new Mesh();
mesh.vertices = vertices;
mesh.triangles = triangles;
mesh.uv = uvs;
mesh.RecalculateNormals();
//メッシュを描画するやつ
MeshFilter meshFilter = gameObject.GetComponent <MeshFilter> ();
if (!meshFilter)
{
meshFilter = gameObject.AddComponent <MeshFilter> ();
}
//メッシュの見え方のやつ
MeshRenderer meshRenderer = gameObject.GetComponent <MeshRenderer> ();
if (!meshRenderer)
{
meshRenderer = gameObject.AddComponent <MeshRenderer> ();
}
//メッシュコライダー
MeshCollider meshCollider = gameObject.GetComponent <MeshCollider> ();
if (!meshCollider)
{
meshCollider = gameObject.AddComponent <MeshCollider> ();
}
//それぞれ適用
meshFilter.sharedMesh = mesh;
meshRenderer.sharedMaterial = stageMaterial;
meshCollider.sharedMesh = mesh;
//フラットなメッシュに変換
MeshFilter mf = GetComponent <MeshFilter> ();
mesh = mf.sharedMesh;
mf.sharedMesh = mesh;
Vector3[] oldVerts = mesh.vertices;
Vector2[] oldUvs = mesh.uv;
triangles = mesh.triangles;
vertices = new Vector3[triangles.Length];
uvs = new Vector2[triangles.Length];
for (int i = 0; i < triangles.Length; i++)
{
vertices[i] = oldVerts[triangles[i]];
uvs[i] = oldUvs[triangles[i]];
triangles[i] = i;
}
mesh.vertices = vertices;
mesh.triangles = triangles;
mesh.uv = uvs;
mesh.RecalculateNormals();
//スタティックにする
gameObject.isStatic = true;
}
public static Color GetRandomColor()
{
ColorHSV col = new ColorHSV(Random.Range(0.0f, 360f), 1f, 1f);
return col.ToColor();
}
