mirror of
https://github.com/jkocon/g-helper.git
synced 2026-02-23 13:00:52 +01:00
401 lines
13 KiB
C#
401 lines
13 KiB
C#
using GHelper.Helpers;
|
|
using System.Management;
|
|
|
|
namespace GHelper.Display
|
|
{
|
|
public enum SplendidGamut : int
|
|
{
|
|
VivoNative = 0,
|
|
VivoSRGB = 1,
|
|
VivoDCIP3 = 3,
|
|
ViviDisplayP3 = 4,
|
|
Native = 50,
|
|
sRGB = 51,
|
|
DCIP3 = 53,
|
|
DisplayP3 = 54
|
|
}
|
|
|
|
public enum SplendidCommand : int
|
|
{
|
|
None = -1,
|
|
|
|
VivoNormal = 1,
|
|
VivoVivid = 2,
|
|
VivoManual = 6,
|
|
VivoEycare = 7,
|
|
|
|
Init = 10,
|
|
DimmingVivo = 9,
|
|
DimmingVisual = 19,
|
|
GamutMode = 200,
|
|
|
|
Default = 11,
|
|
Racing = 21,
|
|
Scenery = 22,
|
|
RTS = 23,
|
|
FPS = 24,
|
|
Cinema = 25,
|
|
Vivid = 13,
|
|
Eyecare = 17,
|
|
}
|
|
public static class VisualControl
|
|
{
|
|
public static DisplayGammaRamp? gammaRamp;
|
|
|
|
private static int _brightness = 100;
|
|
private static bool _init = true;
|
|
private static string? _splendidPath = null;
|
|
|
|
private static System.Timers.Timer brightnessTimer = new System.Timers.Timer(200);
|
|
|
|
public const int DefaultColorTemp = 50;
|
|
|
|
public static bool forceVisual = false;
|
|
public static bool skipGamut = false;
|
|
|
|
static VisualControl()
|
|
{
|
|
brightnessTimer.Elapsed += BrightnessTimerTimer_Elapsed;
|
|
}
|
|
|
|
public static string GetGameVisualPath()
|
|
{
|
|
return Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData) + "\\ASUS\\GameVisual";
|
|
}
|
|
|
|
public static string GetVivobookPath()
|
|
{
|
|
return Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData) + "\\ASUS\\ASUS System Control Interface\\ASUSOptimization\\Splendid";
|
|
}
|
|
|
|
public static SplendidGamut GetDefaultGamut()
|
|
{
|
|
return AppConfig.IsVivoZenPro() ? SplendidGamut.VivoNative : SplendidGamut.Native;
|
|
}
|
|
|
|
public static Dictionary<SplendidGamut, string> GetGamutModes()
|
|
{
|
|
|
|
bool isVivo = AppConfig.IsVivoZenPro();
|
|
|
|
Dictionary<SplendidGamut, string> _modes = new Dictionary<SplendidGamut, string>();
|
|
|
|
string iccPath = isVivo ? GetVivobookPath() : GetGameVisualPath();
|
|
|
|
if (!Directory.Exists(iccPath))
|
|
{
|
|
Logger.WriteLine(iccPath + " doesn't exit");
|
|
return _modes;
|
|
}
|
|
|
|
try
|
|
{
|
|
DirectoryInfo d = new DirectoryInfo(iccPath);
|
|
FileInfo[] icms = d.GetFiles("*.icm");
|
|
if (icms.Length == 0) return _modes;
|
|
|
|
_modes.Add(isVivo ? SplendidGamut.VivoNative : SplendidGamut.Native, "Gamut: Native");
|
|
foreach (FileInfo icm in icms)
|
|
{
|
|
//Logger.WriteLine(icm.FullName);
|
|
|
|
if (icm.Name.Contains("sRGB"))
|
|
{
|
|
try
|
|
{
|
|
_modes.Add(isVivo ? SplendidGamut.VivoSRGB : SplendidGamut.sRGB, "Gamut: sRGB");
|
|
Logger.WriteLine(icm.FullName + " sRGB");
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
if (icm.Name.Contains("DCIP3"))
|
|
{
|
|
try
|
|
{
|
|
_modes.Add(isVivo ? SplendidGamut.VivoDCIP3 : SplendidGamut.DCIP3, "Gamut: DCIP3");
|
|
Logger.WriteLine(icm.FullName + " DCIP3");
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
if (icm.Name.Contains("DisplayP3"))
|
|
{
|
|
try
|
|
{
|
|
_modes.Add(isVivo ? SplendidGamut.ViviDisplayP3 : SplendidGamut.DisplayP3, "Gamut: DisplayP3");
|
|
Logger.WriteLine(icm.FullName + " DisplayP3");
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
}
|
|
return _modes;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
//Logger.WriteLine(ex.Message);
|
|
Logger.WriteLine(ex.ToString());
|
|
return _modes;
|
|
}
|
|
|
|
}
|
|
|
|
public static SplendidCommand GetDefaultVisualMode()
|
|
{
|
|
return AppConfig.IsVivoZenPro() ? SplendidCommand.VivoNormal : SplendidCommand.Default;
|
|
}
|
|
|
|
public static Dictionary<SplendidCommand, string> GetVisualModes()
|
|
{
|
|
|
|
if (AppConfig.IsVivoZenPro())
|
|
{
|
|
return new Dictionary<SplendidCommand, string>
|
|
{
|
|
{ SplendidCommand.VivoNormal, "Default" },
|
|
{ SplendidCommand.VivoVivid, "Vivid" },
|
|
{ SplendidCommand.VivoManual, "Manual" },
|
|
{ SplendidCommand.VivoEycare, "Eyecare" },
|
|
};
|
|
}
|
|
|
|
return new Dictionary<SplendidCommand, string>
|
|
{
|
|
{ SplendidCommand.Default, "Default"},
|
|
{ SplendidCommand.Racing, "Racing"},
|
|
{ SplendidCommand.Scenery, "Scenery"},
|
|
{ SplendidCommand.RTS, "RTS/RPG"},
|
|
{ SplendidCommand.FPS, "FPS"},
|
|
{ SplendidCommand.Cinema, "Cinema"},
|
|
{ SplendidCommand.Vivid, "Vivid" },
|
|
{ SplendidCommand.Eyecare, "Eyecare"}
|
|
};
|
|
}
|
|
|
|
public static Dictionary<int, string> GetTemperatures()
|
|
{
|
|
return new Dictionary<int, string>
|
|
{
|
|
{ 0, "Warmest"},
|
|
{ 15, "Warmer"},
|
|
{ 30, "Warm"},
|
|
{ 50, "Neutral"},
|
|
{ 70, "Cold"},
|
|
{ 85, "Colder"},
|
|
{ 100, "Coldest"},
|
|
};
|
|
}
|
|
|
|
public static Dictionary<int, string> GetEyeCares()
|
|
{
|
|
return new Dictionary<int, string>
|
|
{
|
|
{ 0, "0"},
|
|
{ 1, "1"},
|
|
{ 2, "2"},
|
|
{ 3, "3"},
|
|
{ 4, "4"},
|
|
};
|
|
}
|
|
|
|
public static void SetGamut(int mode = -1)
|
|
{
|
|
if (skipGamut) return;
|
|
if (mode < 0) mode = (int)GetDefaultGamut();
|
|
|
|
AppConfig.Set("gamut", mode);
|
|
|
|
if (RunSplendid(SplendidCommand.GamutMode, 0, mode)) return;
|
|
|
|
if (_init)
|
|
{
|
|
_init = false;
|
|
RunSplendid(SplendidCommand.Init);
|
|
RunSplendid(SplendidCommand.GamutMode, 0, mode);
|
|
}
|
|
}
|
|
|
|
public static void SetVisual(SplendidCommand mode = SplendidCommand.Default, int whiteBalance = DefaultColorTemp, bool init = false)
|
|
{
|
|
if (mode == SplendidCommand.None) return;
|
|
if ((mode == SplendidCommand.Default || mode == SplendidCommand.VivoNormal) && init) return; // Skip default setting on init
|
|
|
|
if (!forceVisual && ScreenCCD.GetHDRStatus(true)) return;
|
|
if (!forceVisual && ScreenNative.GetRefreshRate(ScreenNative.FindLaptopScreen(true)) < 0) return;
|
|
|
|
AppConfig.Set("visual", (int)mode);
|
|
AppConfig.Set("color_temp", whiteBalance);
|
|
|
|
if (whiteBalance != DefaultColorTemp && !init) ProcessHelper.RunAsAdmin();
|
|
|
|
int? balance;
|
|
|
|
switch (mode)
|
|
{
|
|
case SplendidCommand.Eyecare:
|
|
balance = 2;
|
|
break;
|
|
case SplendidCommand.VivoNormal:
|
|
case SplendidCommand.VivoVivid:
|
|
balance = null;
|
|
break;
|
|
case SplendidCommand.VivoEycare:
|
|
balance = Math.Abs(whiteBalance - 50) * 4 / 50;
|
|
break;
|
|
default:
|
|
balance = whiteBalance;
|
|
break;
|
|
}
|
|
|
|
if (RunSplendid(mode, 0, balance)) return;
|
|
|
|
if (_init)
|
|
{
|
|
_init = false;
|
|
RunSplendid(SplendidCommand.Init);
|
|
RunSplendid(mode, 0, balance);
|
|
}
|
|
}
|
|
|
|
private static string GetSplendidPath()
|
|
{
|
|
if (_splendidPath == null)
|
|
{
|
|
try
|
|
{
|
|
using (var searcher = new ManagementObjectSearcher(@"Select * from Win32_SystemDriver WHERE Name='ATKWMIACPIIO'"))
|
|
{
|
|
foreach (var driver in searcher.Get())
|
|
{
|
|
string path = driver["PathName"].ToString();
|
|
_splendidPath = Path.GetDirectoryName(path) + "\\AsusSplendid.exe";
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.WriteLine(ex.Message);
|
|
}
|
|
}
|
|
|
|
return _splendidPath;
|
|
}
|
|
|
|
private static bool RunSplendid(SplendidCommand command, int? param1 = null, int? param2 = null)
|
|
{
|
|
var splendid = GetSplendidPath();
|
|
bool isVivo = AppConfig.IsVivoZenPro();
|
|
bool isSplenddid = File.Exists(splendid);
|
|
|
|
if (isSplenddid)
|
|
{
|
|
if (command == SplendidCommand.DimmingVisual && isVivo) command = SplendidCommand.DimmingVivo;
|
|
var result = ProcessHelper.RunCMD(splendid, (int)command + " " + param1 + " " + param2);
|
|
if (result.Contains("file not exist") || (result.Length == 0 && !isVivo)) return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private static void BrightnessTimerTimer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
|
|
{
|
|
brightnessTimer.Stop();
|
|
|
|
|
|
if (RunSplendid(SplendidCommand.DimmingVisual, 0, (int)(40 + _brightness * 0.6))) return;
|
|
|
|
if (_init)
|
|
{
|
|
_init = false;
|
|
RunSplendid(SplendidCommand.Init);
|
|
RunSplendid(SplendidCommand.Init, 4);
|
|
if (RunSplendid(SplendidCommand.DimmingVisual, 0, (int)(40 + _brightness * 0.6))) return;
|
|
}
|
|
|
|
// GammaRamp Fallback
|
|
SetGamma(_brightness);
|
|
}
|
|
|
|
public static int SetBrightness(int brightness = -1, int delta = 0)
|
|
{
|
|
if (!AppConfig.IsOLED()) return -1;
|
|
|
|
if (brightness < 0) brightness = AppConfig.Get("brightness", 100);
|
|
|
|
_brightness = Math.Max(0, Math.Min(100, brightness + delta));
|
|
AppConfig.Set("brightness", _brightness);
|
|
|
|
brightnessTimer.Start();
|
|
|
|
Program.settingsForm.VisualiseBrightness();
|
|
//if (brightness < 100) ResetGamut();
|
|
|
|
return _brightness;
|
|
}
|
|
|
|
public static void ResetGamut()
|
|
{
|
|
int defaultGamut = (int)GetDefaultGamut();
|
|
|
|
if (AppConfig.Get("gamut") != defaultGamut)
|
|
{
|
|
skipGamut = true;
|
|
AppConfig.Set("gamut", defaultGamut);
|
|
Program.settingsForm.VisualiseGamut();
|
|
skipGamut = false;
|
|
}
|
|
}
|
|
|
|
|
|
public static void SetGamma(int brightness = 100)
|
|
{
|
|
var bright = Math.Round((float)brightness / 200 + 0.5, 2);
|
|
|
|
var screenName = ScreenNative.FindLaptopScreen();
|
|
if (screenName is null) return;
|
|
|
|
try
|
|
{
|
|
var handle = ScreenNative.CreateDC(screenName, screenName, null, IntPtr.Zero);
|
|
if (gammaRamp is null)
|
|
{
|
|
var gammaDump = new GammaRamp();
|
|
if (ScreenNative.GetDeviceGammaRamp(handle, ref gammaDump))
|
|
{
|
|
gammaRamp = new DisplayGammaRamp(gammaDump);
|
|
//Logger.WriteLine("Gamma R: " + string.Join("-", gammaRamp.Red));
|
|
//Logger.WriteLine("Gamma G: " + string.Join("-", gammaRamp.Green));
|
|
//Logger.WriteLine("Gamma B: " + string.Join("-", gammaRamp.Blue));
|
|
}
|
|
}
|
|
|
|
if (gammaRamp is null || !gammaRamp.IsOriginal())
|
|
{
|
|
Logger.WriteLine("Not default Gamma");
|
|
gammaRamp = new DisplayGammaRamp();
|
|
}
|
|
|
|
var ramp = gammaRamp.AsBrightnessRamp(bright);
|
|
bool result = ScreenNative.SetDeviceGammaRamp(handle, ref ramp);
|
|
|
|
Logger.WriteLine("Gamma " + bright.ToString() + ": " + result);
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.WriteLine(ex.ToString());
|
|
}
|
|
|
|
//ScreenBrightness.Set(60 + (int)(40 * bright));
|
|
}
|
|
|
|
}
|
|
}
|