326 lines
16 KiB
C#
326 lines
16 KiB
C#
using Colourful;
|
|
using Dalamud.Game.ClientState.Objects.Enums;
|
|
using Dalamud.Game.ClientState.Objects.SubKinds;
|
|
using Dalamud.Game.ClientState.Objects.Types;
|
|
using HSUI.Config;
|
|
using HSUI.Enums;
|
|
using HSUI.Interface.GeneralElements;
|
|
using System;
|
|
using System.Numerics;
|
|
|
|
namespace HSUI.Helpers
|
|
{
|
|
public static class ColorUtils
|
|
{
|
|
|
|
//Build our converter objects and store them in a field. This will be used to convert our PluginConfigColors into different color spaces to be used for interpolation
|
|
private static readonly IColorConverter<RGBColor, LabColor> _rgbToLab = new ConverterBuilder().FromRGB().ToLab().Build();
|
|
private static readonly IColorConverter<LabColor, RGBColor> _labToRgb = new ConverterBuilder().FromLab().ToRGB().Build();
|
|
|
|
private static readonly IColorConverter<RGBColor, LChabColor> _rgbToLChab = new ConverterBuilder().FromRGB().ToLChab().Build();
|
|
private static readonly IColorConverter<LChabColor, RGBColor> _lchabToRgb = new ConverterBuilder().FromLChab().ToRGB().Build();
|
|
|
|
private static readonly IColorConverter<RGBColor, XYZColor> _rgbToXyz = new ConverterBuilder().FromRGB(RGBWorkingSpaces.sRGB).ToXYZ(Illuminants.D65).Build();
|
|
private static readonly IColorConverter<XYZColor, RGBColor> _xyzToRgb = new ConverterBuilder().FromXYZ(Illuminants.D65).ToRGB(RGBWorkingSpaces.sRGB).Build();
|
|
|
|
private static readonly IColorConverter<RGBColor, LChuvColor> _rgbToLChuv = new ConverterBuilder().FromRGB().ToLChuv().Build();
|
|
private static readonly IColorConverter<LChuvColor, RGBColor> _lchuvToRgb = new ConverterBuilder().FromLChuv().ToRGB().Build();
|
|
|
|
private static readonly IColorConverter<RGBColor, LuvColor> _rgbToLuv = new ConverterBuilder().FromRGB().ToLuv().Build();
|
|
private static readonly IColorConverter<LuvColor, RGBColor> _luvToRgb = new ConverterBuilder().FromLuv().ToRGB().Build();
|
|
|
|
private static readonly IColorConverter<RGBColor, JzazbzColor> _rgbToJzazbz = new ConverterBuilder().FromRGB().ToJzazbz().Build();
|
|
private static readonly IColorConverter<JzazbzColor, RGBColor> _jzazbzToRgb = new ConverterBuilder().FromJzazbz().ToRGB().Build();
|
|
|
|
private static readonly IColorConverter<RGBColor, JzCzhzColor> _rgbToJzCzhz = new ConverterBuilder().FromRGB().ToJzCzhz().Build();
|
|
private static readonly IColorConverter<JzCzhzColor, RGBColor> _jzCzhzToRgb = new ConverterBuilder().FromJzCzhz().ToRGB().Build();
|
|
|
|
//Simple LinearInterpolation method. T = [0 , 1]
|
|
private static float LinearInterpolation(float left, float right, float t)
|
|
=> left + ((right - left) * t);
|
|
|
|
public static PluginConfigColor GetColorByScale(float i, ColorByHealthValueConfig config) =>
|
|
GetColorByScale(i, config.LowHealthColorThreshold / 100f, config.FullHealthColorThreshold / 100f, config.LowHealthColor, config.FullHealthColor, config.MaxHealthColor, config.UseMaxHealthColor, config.BlendMode);
|
|
|
|
//Method used to interpolate two PluginConfigColors
|
|
//i is scale [0 , 1]
|
|
//min and max are used for color thresholds. for instance return colorLeft if i < min or return ColorRight if i > max
|
|
public static PluginConfigColor GetColorByScale(float i, float min, float max, PluginConfigColor colorLeft, PluginConfigColor colorRight, PluginConfigColor colorMax, bool useMaxColor, BlendMode blendMode)
|
|
{
|
|
try
|
|
{
|
|
// Guard against null/invalid config (can happen with corrupted or migrated config)
|
|
if (colorLeft == null || colorRight == null || colorMax == null)
|
|
return PluginConfigColor.FromHex(0xFF808080);
|
|
|
|
//Set our thresholds where the ratio is the range of values we will use for interpolation.
|
|
//Values outside this range will either return colorLeft or colorRight
|
|
float ratio = i;
|
|
if (min > 0 || max < 1)
|
|
{
|
|
if (i < min)
|
|
{
|
|
ratio = 0;
|
|
}
|
|
else if (i > max)
|
|
{
|
|
ratio = 1;
|
|
}
|
|
else
|
|
{
|
|
float range = max - min;
|
|
if (MathF.Abs(range) < 0.0001f) ratio = 1; // avoid divide-by-zero when min==max
|
|
else ratio = (i - min) / range;
|
|
}
|
|
}
|
|
|
|
//Convert our PluginConfigColor to RGBColor
|
|
RGBColor rgbColorLeft = new RGBColor(colorLeft.Vector.X, colorLeft.Vector.Y, colorLeft.Vector.Z);
|
|
RGBColor rgbColorRight = new RGBColor(colorRight.Vector.X, colorRight.Vector.Y, colorRight.Vector.Z);
|
|
|
|
//Interpolate our Alpha now
|
|
float alpha = LinearInterpolation(colorLeft.Vector.W, colorRight.Vector.W, ratio);
|
|
|
|
if (ratio >= 1 && useMaxColor)
|
|
{
|
|
return new PluginConfigColor(new Vector4((float)colorMax.Vector.X, (float)colorMax.Vector.Y, (float)colorMax.Vector.Z, colorMax.Vector.W));
|
|
}
|
|
|
|
//Allow the users to select different blend modes since interpolating between two colors can result in different blending depending on the color space
|
|
//We convert our RGBColor values into different color spaces. We then interpolate each channel before converting the color back into RGBColor space
|
|
switch (blendMode)
|
|
{
|
|
case BlendMode.LAB:
|
|
{
|
|
//convert RGB to LAB
|
|
LabColor LabLeft = _rgbToLab.Convert(rgbColorLeft);
|
|
LabColor LabRight = _rgbToLab.Convert(rgbColorRight);
|
|
|
|
RGBColor Lab2RGB = _labToRgb.Convert(
|
|
new LabColor(
|
|
LinearInterpolation((float)LabLeft.L, (float)LabRight.L, ratio),
|
|
LinearInterpolation((float)LabLeft.a, (float)LabRight.a, ratio),
|
|
LinearInterpolation((float)LabLeft.b, (float)LabRight.b, ratio)
|
|
)
|
|
);
|
|
|
|
Lab2RGB.NormalizeIntensity();
|
|
return new PluginConfigColor(new Vector4((float)Lab2RGB.R, (float)Lab2RGB.G, (float)Lab2RGB.B, alpha));
|
|
}
|
|
|
|
case BlendMode.LChab:
|
|
{
|
|
//convert RGB to LChab
|
|
LChabColor LChabLeft = _rgbToLChab.Convert(rgbColorLeft);
|
|
LChabColor LChabRight = _rgbToLChab.Convert(rgbColorRight);
|
|
|
|
RGBColor LChab2RGB = _lchabToRgb.Convert(
|
|
new LChabColor(
|
|
LinearInterpolation((float)LChabLeft.L, (float)LChabRight.L, ratio),
|
|
LinearInterpolation((float)LChabLeft.C, (float)LChabRight.C, ratio),
|
|
LinearInterpolation((float)LChabLeft.h, (float)LChabRight.h, ratio)
|
|
)
|
|
);
|
|
|
|
LChab2RGB.NormalizeIntensity();
|
|
|
|
return new PluginConfigColor(new Vector4((float)LChab2RGB.R, (float)LChab2RGB.G, (float)LChab2RGB.B, alpha));
|
|
}
|
|
case BlendMode.XYZ:
|
|
{
|
|
//convert RGB to XYZ
|
|
XYZColor XYZLeft = _rgbToXyz.Convert(rgbColorLeft);
|
|
XYZColor XYZRight = _rgbToXyz.Convert(rgbColorRight);
|
|
|
|
RGBColor XYZ2RGB = _xyzToRgb.Convert(
|
|
new XYZColor(
|
|
LinearInterpolation((float)XYZLeft.X, (float)XYZRight.X, ratio),
|
|
LinearInterpolation((float)XYZLeft.Y, (float)XYZRight.Y, ratio),
|
|
LinearInterpolation((float)XYZLeft.Z, (float)XYZRight.Z, ratio)
|
|
)
|
|
);
|
|
|
|
XYZ2RGB.NormalizeIntensity();
|
|
|
|
return new PluginConfigColor(new Vector4((float)XYZ2RGB.R, (float)XYZ2RGB.G, (float)XYZ2RGB.B, alpha));
|
|
}
|
|
case BlendMode.RGB:
|
|
{
|
|
//No conversion needed here because we are already working in RGB space
|
|
RGBColor newRGB = new RGBColor(
|
|
LinearInterpolation((float)rgbColorLeft.R, (float)rgbColorRight.R, ratio),
|
|
LinearInterpolation((float)rgbColorLeft.G, (float)rgbColorRight.G, ratio),
|
|
LinearInterpolation((float)rgbColorLeft.B, (float)rgbColorRight.B, ratio)
|
|
);
|
|
|
|
return new PluginConfigColor(new Vector4((float)newRGB.R, (float)newRGB.G, (float)newRGB.B, alpha));
|
|
}
|
|
case BlendMode.LChuv:
|
|
{
|
|
//convert RGB to LChuv
|
|
LChuvColor LChuvLeft = _rgbToLChuv.Convert(rgbColorLeft);
|
|
LChuvColor LChuvRight = _rgbToLChuv.Convert(rgbColorRight);
|
|
|
|
RGBColor LChuv2RGB = _lchuvToRgb.Convert(
|
|
new LChuvColor(
|
|
LinearInterpolation((float)LChuvLeft.L, (float)LChuvRight.L, ratio),
|
|
LinearInterpolation((float)LChuvLeft.C, (float)LChuvRight.C, ratio),
|
|
LinearInterpolation((float)LChuvLeft.h, (float)LChuvRight.h, ratio)
|
|
)
|
|
);
|
|
|
|
LChuv2RGB.NormalizeIntensity();
|
|
|
|
return new PluginConfigColor(new Vector4((float)LChuv2RGB.R, (float)LChuv2RGB.G, (float)LChuv2RGB.B, alpha));
|
|
}
|
|
|
|
case BlendMode.Luv:
|
|
{
|
|
//convert RGB to Luv
|
|
LuvColor LuvLeft = _rgbToLuv.Convert(rgbColorLeft);
|
|
LuvColor LuvRight = _rgbToLuv.Convert(rgbColorRight);
|
|
|
|
RGBColor Luv2RGB = _luvToRgb.Convert(
|
|
new LuvColor(
|
|
LinearInterpolation((float)LuvLeft.L, (float)LuvRight.L, ratio),
|
|
LinearInterpolation((float)LuvLeft.u, (float)LuvRight.u, ratio),
|
|
LinearInterpolation((float)LuvLeft.v, (float)LuvRight.v, ratio)
|
|
)
|
|
);
|
|
|
|
Luv2RGB.NormalizeIntensity();
|
|
|
|
return new PluginConfigColor(new Vector4((float)Luv2RGB.R, (float)Luv2RGB.G, (float)Luv2RGB.B, alpha));
|
|
|
|
}
|
|
case BlendMode.Jzazbz:
|
|
{
|
|
//convert RGB to Jzazbz
|
|
JzazbzColor JzazbzLeft = _rgbToJzazbz.Convert(rgbColorLeft);
|
|
JzazbzColor JzazbzRight = _rgbToJzazbz.Convert(rgbColorRight);
|
|
|
|
RGBColor Jzazbz2RGB = _jzazbzToRgb.Convert(
|
|
new JzazbzColor(
|
|
LinearInterpolation((float)JzazbzLeft.Jz, (float)JzazbzRight.Jz, ratio),
|
|
LinearInterpolation((float)JzazbzLeft.az, (float)JzazbzRight.az, ratio),
|
|
LinearInterpolation((float)JzazbzLeft.bz, (float)JzazbzRight.bz, ratio)
|
|
)
|
|
);
|
|
|
|
Jzazbz2RGB.NormalizeIntensity();
|
|
|
|
return new PluginConfigColor(new Vector4((float)Jzazbz2RGB.R, (float)Jzazbz2RGB.G, (float)Jzazbz2RGB.B, alpha));
|
|
}
|
|
case BlendMode.JzCzhz:
|
|
{
|
|
//convert RGB to JzCzhz
|
|
JzCzhzColor JzCzhzLeft = _rgbToJzCzhz.Convert(rgbColorLeft);
|
|
JzCzhzColor JzCzhzRight = _rgbToJzCzhz.Convert(rgbColorRight);
|
|
|
|
RGBColor JzCzhz2RGB = _jzCzhzToRgb.Convert(
|
|
new JzCzhzColor(
|
|
LinearInterpolation((float)JzCzhzLeft.Jz, (float)JzCzhzRight.Jz, ratio),
|
|
LinearInterpolation((float)JzCzhzLeft.Cz, (float)JzCzhzRight.Cz, ratio),
|
|
LinearInterpolation((float)JzCzhzLeft.hz, (float)JzCzhzRight.hz, ratio)
|
|
)
|
|
);
|
|
|
|
JzCzhz2RGB.NormalizeIntensity();
|
|
|
|
return new PluginConfigColor(new Vector4((float)JzCzhz2RGB.R, (float)JzCzhz2RGB.G, (float)JzCzhz2RGB.B, alpha));
|
|
}
|
|
}
|
|
return new(Vector4.One);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Plugin.Logger.Warning($"[HSUI] GetColorByScale failed (config may be corrupted): {ex.Message}");
|
|
return PluginConfigColor.FromHex(0xFF808080);
|
|
}
|
|
}
|
|
|
|
public static PluginConfigColor ColorForActor(IGameObject? actor)
|
|
{
|
|
if (actor == null || actor is not ICharacter character)
|
|
{
|
|
return GlobalColors.Instance.NPCNeutralColor;
|
|
}
|
|
|
|
if (character.ObjectKind == ObjectKind.Player ||
|
|
character.SubKind == 9 && character.ClassJob.RowId > 0)
|
|
{
|
|
return GlobalColors.Instance.SafeColorForJobId(character.ClassJob.RowId);
|
|
}
|
|
|
|
bool isHostile = Utils.IsHostile(character);
|
|
|
|
if (character is IBattleNpc npc)
|
|
{
|
|
if ((npc.BattleNpcKind == BattleNpcSubKind.Enemy || npc.BattleNpcKind == BattleNpcSubKind.BattleNpcPart) && isHostile)
|
|
{
|
|
return GlobalColors.Instance.NPCHostileColor;
|
|
}
|
|
else
|
|
{
|
|
return GlobalColors.Instance.NPCFriendlyColor;
|
|
}
|
|
}
|
|
|
|
return isHostile ? GlobalColors.Instance.NPCNeutralColor : GlobalColors.Instance.NPCFriendlyColor;
|
|
}
|
|
|
|
public static PluginConfigColor? ColorForCharacter(
|
|
IGameObject? gameObject,
|
|
uint currentHp = 0,
|
|
uint maxHp = 0,
|
|
bool useJobColor = false,
|
|
bool useRoleColor = false,
|
|
ColorByHealthValueConfig? colorByHealthConfig = null)
|
|
{
|
|
ICharacter? character = gameObject as ICharacter;
|
|
|
|
if (useJobColor && character != null)
|
|
{
|
|
return ColorForActor(character);
|
|
}
|
|
else if (useRoleColor)
|
|
{
|
|
return character is IPlayerCharacter ?
|
|
GlobalColors.Instance.SafeRoleColorForJobId(character.ClassJob.RowId) :
|
|
ColorForActor(character);
|
|
}
|
|
else if (colorByHealthConfig != null && colorByHealthConfig.Enabled && character != null)
|
|
{
|
|
var scale = (float)currentHp / Math.Max(1, maxHp);
|
|
if (colorByHealthConfig.UseJobColorAsMaxHealth)
|
|
{
|
|
return GetColorByScale(
|
|
scale,
|
|
colorByHealthConfig.LowHealthColorThreshold / 100f,
|
|
colorByHealthConfig.FullHealthColorThreshold / 100f,
|
|
colorByHealthConfig.LowHealthColor,
|
|
colorByHealthConfig.FullHealthColor,
|
|
ColorForActor(character),
|
|
colorByHealthConfig.UseMaxHealthColor,
|
|
colorByHealthConfig.BlendMode
|
|
);
|
|
}
|
|
else if (colorByHealthConfig.UseRoleColorAsMaxHealth)
|
|
{
|
|
return GetColorByScale(scale,
|
|
colorByHealthConfig.LowHealthColorThreshold / 100f,
|
|
colorByHealthConfig.FullHealthColorThreshold / 100f,
|
|
colorByHealthConfig.LowHealthColor, colorByHealthConfig.FullHealthColor,
|
|
character is IPlayerCharacter ? GlobalColors.Instance.SafeRoleColorForJobId(character.ClassJob.RowId) : ColorForActor(character),
|
|
colorByHealthConfig.UseMaxHealthColor,
|
|
colorByHealthConfig.BlendMode
|
|
);
|
|
}
|
|
return GetColorByScale(scale, colorByHealthConfig);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
}
|