public void setMixAlgo(mixingMethod newMixAlgo, int i)
{
mixAlgo = newMixAlgo;
updateMixture(Camera.main.GetComponent <demo_colors>().getAllColors(), Camera.main.GetComponent <demo_colors>().getAllQuants());
theGO.GetComponent <mixtureRefs>().justSet = true;
theGO.GetComponent <mixtureRefs>().mixingGO.GetComponent <Dropdown>().value = i;
theGO.GetComponent <mixtureRefs>().justSet = false;
}
public void setMixAlgo(mixingMethod newMixAlgo)
{
int newIndex = 0;
switch (newMixAlgo)
{
case mixingMethod.colorComponentAveraging:
newIndex = 0;
break;
case mixingMethod.colorAveraging:
newIndex = 1;
break;
case mixingMethod.spaceAveraging:
newIndex = 2;
break;
}
setMixAlgo(newMixAlgo, newIndex);
}
public void addMixture(desiredMixtureType aimingFor, bool ignoreQuants, colorSpace csUsed, mixingMethod mixAlgo)
{
GameObject newMixtureDataGO = Instantiate(mixtureDataPrefab, mixtureListPanel.transform);
mixtureDataList.Add(newMixtureDataGO, new mixtureData(newMixtureDataGO, aimingFor, ignoreQuants, csUsed, mixAlgo));
mixtureDataList[newMixtureDataGO].updateMixture(Camera.main.GetComponent <demo_colors>().getAllColors(), Camera.main.GetComponent <demo_colors>().getAllQuants());
}
public mixtureData(GameObject GO, desiredMixtureType AF, bool IQ, colorSpace CSU, mixingMethod MM)
{
theGO = GO;
setAimingFor(AF);
setIgnoreQuants(IQ);
setCSUsed(CSU);
setMixAlgo(MM);
}
static Color mixColors_inCMYK_colorSpace(Color[] colors, float[] colorQuantities, mixingMethod mm, bool ignoreQuants)
{
List <float[]> passedColors = new List <float[]>();
for (int i = 0; i < colors.Length; i++)
{
float[] colorFloat_RGB = colorTypeConversion.color_to_array(colors[i]);
float[] color255_RGB = colorFormatConversion._float_to_255(colorFloat_RGB);
float[] color255_CMYK = rgb2cmyk_cmyk2rgb.rgb255_to_cmyk255(color255_RGB);
passedColors.Add(color255_CMYK);
}
float[] result255_CMYK = (ignoreQuants == false) ? mixingMethods.mixColors(passedColors, colorQuantities, mm) : mixingMethods.mixColors(passedColors, mm); //actual Color Mixing
float[] result255_RGB = rgb2cmyk_cmyk2rgb.cmyk255_to_rgb255(result255_CMYK);
float[] resultFloat_RGB = colorFormatConversion._255_to_float(result255_RGB);
return(colorTypeConversion.array_to_color(resultFloat_RGB));
}
//Ignore Quants == true
public static Color mixColors(Color[] colors, colorSpace csToUse, mixingMethod mm)
{
float[] colorQuantities = new float[0]; //create it to meet requirements
return(mixColors(colors, colorQuantities, csToUse, mm, true));
}
//Ignore Quants == false
public static Color mixColors(Color[] colors, float[] colorQuantities, colorSpace csToUse, mixingMethod mm)
{
return(mixColors(colors, colorQuantities, csToUse, mm, false));
}
static Color mixColors(Color[] colors, float[] colorQuantities, colorSpace csToUse, mixingMethod mm, bool ignoreQuants)
{
switch (csToUse)
{
case colorSpace.RGB:
return(mixColors_inRGB_colorSpace(colors, colorQuantities, mm, ignoreQuants));
case colorSpace.RYB:
return(mixColors_inRYB_colorSpace(colors, colorQuantities, mm, ignoreQuants));
default:
return(mixColors_inCMYK_colorSpace(colors, colorQuantities, mm, ignoreQuants));
}
}
public static Color mixColors(this Color[] colors, float[] colorQuantities, colorSpace csToUse, mixingMethod mm)
{
return(colorMixing.mixColors(colors, colorQuantities, csToUse, mm));
}
public static float[] mixColors(this List <float[]> colors, float[] colorQuantities, mixingMethod mm)
{
return(mixingMethods.mixColors(colors, colorQuantities, mm));
}
public static float[] mixColors(this Color c, List <float[]> colors, mixingMethod mm)
{
return(mixingMethods.mixColors(colors, mm));
}
public static Color mixColors(this Color c, Color[] colors, colorSpace csToUse, mixingMethod mm)
{
return(colorMixing.mixColors(colors, csToUse, mm));
}
//BASE CODE
static float[] mixColors(List <float[]> colors, float[] colorQuantities, mixingMethod mm, bool ignoreQuants)
{
if (
//COLOR QUANTITIES SHOULD BE POSITIVE... but I WILL NOT CHECK THIS...
//COLORS SHOULD BE IN THE SAME COLOR SPACE (rgb,ryb,cmyk) -AND- FORMAT (255,float)... but I CANNOT CHECK THIS...
(colors[0].Length == 3 || colors[0].Length == 4) && //colors can only be in these formats
(colors.Count > 1) && //we need 2 or more colors to MIX them
((ignoreQuants == false) && (colors.Count == colorQuantities.Length)))
{
switch (mm)
{
case mixingMethod.spaceAveraging:
if (ignoreQuants)
{
return(spaceAveraging(colors));
}
else
{
return(spaceAveraging(colors, colorQuantities));
}
case mixingMethod.colorComponentAveraging:
if (ignoreQuants)
{
return(colorComponentAveraging(colors));
}
else
{
return(colorComponentAveraging(colors, colorQuantities));
}
case mixingMethod.eachAsPercentOfMax:
if (ignoreQuants)
{
return(eachAsPercentOfMax(colors));
}
else
{
return(eachAsPercentOfMax(colors, colorQuantities));
}
default: //colorAveraging
if (ignoreQuants)
{
return(colorAveraging(colors));
}
else
{
return(colorAveraging(colors, colorQuantities));
}
}
}
else
{
if (colors.Count == 1)
{
return(colors[0]);
}
else
{
return(new float[colors[0].Length]);
}
}
}
//Ignore Quants == false
public static float[] mixColors(List <float[]> colors, float[] colorQuantities, mixingMethod mm)
{
return(mixColors(colors, colorQuantities, mm, false));
}
static bool useVect4Dist = true; //might be used later
//-------------------------Originally From Color Mixing-------------------------
//Ignore Quants == true
public static float[] mixColors(List <float[]> colors, mixingMethod mm)
{
float[] colorQuantities = new float[0]; //create it to meet requirements
return(mixColors(colors, colorQuantities, mm, true));
}
