/// <summary> /// Set the current gamma ramp to compensate monitor gamma. /// </summary> /// <param name="hDC"></param> /// <param name="rgamma"></param> /// <param name="ggamma"></param> /// <param name="bgamma"></param> public static void SetGammaRamp(IntPtr hDC, double rgamma, double ggamma, double bgamma) { GammaRamp ramp = new GammaRamp(); // Build gamma ramp in order to compensate monitor gamma ramp.Red = new UInt16[256]; ramp.Green = new UInt16[256]; ramp.Blue = new UInt16[256]; for (uint v = 0; v < 256; v++) { double gamma; // Red ramp gamma = Math.Min(1.0, Math.Pow((double)v / 255.0, 1.0 / rgamma)); ramp.Red[v] = (UInt16)((double)UInt16.MaxValue * gamma); // Green ramp gamma = Math.Min(1.0, Math.Pow((double)v / 255.0, 1.0 / rgamma)); ramp.Green[v] = (UInt16)((double)UInt16.MaxValue * gamma); // Blue ramp gamma = Math.Min(1.0, Math.Pow((double)v / 255.0, 1.0 / rgamma)); ramp.Blue[v] = (UInt16)((double)UInt16.MaxValue * gamma); } // Set ramp SetGammaRamp(hDC, ref ramp); }
private GammaRamp CreateGammaRamp(ColorBalance colorBalance) { // Create native ramp object var ramp = new GammaRamp { Red = new ushort[256], Green = new ushort[256], Blue = new ushort[256] }; // Create linear ramps for each color for (var i = 0; i < 256; i++) { ramp.Red[i] = (ushort)(i * 255 * colorBalance.Red); ramp.Green[i] = (ushort)(i * 255 * colorBalance.Green); ramp.Blue[i] = (ushort)(i * 255 * colorBalance.Blue); } // Some drivers will ignore request to change gamma if the ramp is the same as last time // so we randomize it a bit. Even though our ramp may not have changed, other applications // could have affected the gamma and we need to "force-refresh" it to ensure it's valid. _gammaChannelOffset = ++_gammaChannelOffset % 5; ramp.Red[255] = (ushort)(ramp.Red[255] + _gammaChannelOffset); ramp.Green[255] = (ushort)(ramp.Green[255] + _gammaChannelOffset); ramp.Blue[255] = (ushort)(ramp.Blue[255] + _gammaChannelOffset); return(ramp); }
public void SetGamma(double redMultiplier, double greenMultiplier, double blueMultiplier) { // Create native ramp object var ramp = new GammaRamp { Red = new ushort[256], Green = new ushort[256], Blue = new ushort[256] }; // Create linear ramps for each color for (var i = 0; i < 256; i++) { ramp.Red[i] = (ushort)(i * 255 * redMultiplier); ramp.Green[i] = (ushort)(i * 255 * greenMultiplier); ramp.Blue[i] = (ushort)(i * 255 * blueMultiplier); } // Some drivers will ignore request to change gamma if the ramp is the same as last time // so we randomize it a bit. Even though our ramp may not have changed, other applications // could have affected the gamma and we need to "force-refresh" it to ensure it's valid. _gammaChannelOffset = ++_gammaChannelOffset % 5; ramp.Red[255] = (ushort)(ramp.Red[255] + _gammaChannelOffset); ramp.Green[255] = (ushort)(ramp.Green[255] + _gammaChannelOffset); ramp.Blue[255] = (ushort)(ramp.Blue[255] + _gammaChannelOffset); // Set gamma SetGammaRamp(ramp); }
public unsafe WithGammaRamp(GammaRamp ramp) { Ramp = ramp; GammaTable = Ramp.GammaTable; InvGammaTable = Ramp.InvGammaTable; PAGray = _PAGray; }
public static unsafe void SetGammaRamp(Monitor monitor, ushort[] red, ushort[] green, ushort[] blue) { var ramp = new GammaRamp(); ramp.Red = Marshal.UnsafeAddrOfPinnedArrayElement(red, 0); ramp.Green = Marshal.UnsafeAddrOfPinnedArrayElement(green, 0); ramp.Blue = Marshal.UnsafeAddrOfPinnedArrayElement(blue, 0); glfwSetGammaRamp(monitor.Ptr, new IntPtr(&ramp)); }
/// <summary> /// Get the current gamma ramp. /// </summary> /// <param name="hDC"></param> /// <returns></returns> public static GammaRamp GetGammaRamp(IntPtr hDC) { GammaRamp ramp = new GammaRamp(); if (GetDeviceGammaRamp(hDC, ref ramp) == false) throw new InvalidOperationException("GetDeviceGammaRamp has failed"); return (ramp); }
/// <inheritdoc /> public void SetDisplayGammaLinear(ColorIntensity intensity) { var ramp = new GammaRamp(256); for (var i = 1; i < 256; i++) { ramp.Red[i] = (ushort)(i * 255 * intensity.Red); ramp.Green[i] = (ushort)(i * 255 * intensity.Green); ramp.Blue[i] = (ushort)(i * 255 * intensity.Blue); } SetDisplayGammaRamp(ramp); }
static public void UpdateGammaCorrection() { short[] gray_gamma = new short[256]; //GammaRamp gr = MdxRender.Dev.GetGammaRamp(0); //short[] red_gamma = gr.GetRed(); //short[] green_gamma = gr.GetGreen(); //short[] blue_gamma = gr.GetBlue(); GammaRamp gr = new GammaRamp(); float recip_gray = recip_gamma(GammaFactor); // compute i**(1/gamma) for all i and scale to range for (short i = 0; i < 256; i++) { gray_gamma[i] = ramp_val(i, recip_gray, 255); } gr.SetRed(gray_gamma); gr.SetGreen(gray_gamma); gr.SetBlue(gray_gamma); MdxRender.Dev.SetGammaRamp(0, false, gr); /* * m_gamma[G_GRAY] = m_gamma[G_RED] = m_gamma[G_GREEN] = m_gamma[G_BLUE] * = INITIAL_GAMMA; * * if (m_test_gamma && m_can_gamma_ramp) * { * if (m_single_gamma) * { * // compute 1/gamma * const float recip_gray = recip_gamma(m_gamma[G_GRAY]); * // compute i**(1/gamma) for all i and scale to range * for (UINT i = 0; i < 256; i++) * { * m_ramp.red[i] = m_ramp.green[i] = m_ramp.blue[i] = * ramp_val(i, recip_gray); * } * } * } * else * { * for (UINT i = 0; i < 256; i++) * { * m_ramp.red[i] = m_ramp.green[i] = m_ramp.blue[i] = 65535*i/255; * } * } */ }
/// <summary> /// Change the display gamma based on given curve /// </summary> private void SetDisplayGammaRamp(GammaRamp ramp) { // Offset the values in ramp slightly... // ... this forces the ramp to refresh every time // ... because some drivers will ignore stale ramps // ... while the gamma itself might have been changed _gammaChannelOffset = ++_gammaChannelOffset % 5; ramp.Red[255] = (ushort)(ramp.Red[255] + _gammaChannelOffset); ramp.Green[255] = (ushort)(ramp.Green[255] + _gammaChannelOffset); ramp.Blue[255] = (ushort)(ramp.Blue[255] + _gammaChannelOffset); // Set ramp NativeMethods.SetDeviceGammaRamp(_dc, ref ramp); }
public static void SetGammaRamp(IntPtr monitor, ref GammaRamp ramp) { unsafe { fixed(ushort *rampRed = ramp.Red, rampGreen = ramp.Green, rampBlue = ramp.Blue) { var internalRamp = new UnmanagedGammaRamp { red = rampRed, green = rampGreen, blue = rampBlue, size = ramp.Size }; _SetGammaRamp(monitor, new IntPtr(&internalRamp)); } } }
public static void SetGamma(double red, double green, double blue) { if (red < 0.0 || red > 1.0 || green < 0.0 || green > 1.0 || blue < 0.0 || blue > 1.0) { throw new Exception("Multiplier out of range"); } var ramp = new GammaRamp()//RAMP { Red = new ushort[256], Green = new ushort[256], Blue = new ushort[256] }; for (int i = 0; i <= 255; i++) { int value = i; ramp.Red[i] = (ushort)(Convert.ToByte(value * red) << 8); // bitwise shift left ramp.Green[i] = (ushort)(Convert.ToByte(value * green) << 8); // by 8 ramp.Blue[i] = (ushort)(Convert.ToByte(value * blue) << 8); // same as multiplying by 256 } var screenDC = GetDC(IntPtr.Zero); int counter; for (counter = 1; counter <= 10; counter++) { var result = SetDeviceGammaRamp(screenDC, ref ramp); if (result == false) { // Can't go below 0.50 (3400K) unless flux is installed // and "Expand range" feature activated (flux.exe /unlockwingamma) throw new Exception("Failed to set gamma ramp"); } } ReleaseDC(IntPtr.Zero, screenDC); // required otherwise will leak GDI objects }
public static GammaRamp GetGammaRamp(Monitor monitor) { GammaRamp ramp; GammaRampInternal rampI = Imports.glfwGetGammaRamp(monitor); uint length = rampI.Length; ramp = new GammaRamp(); ramp.Red = new uint[length]; ramp.Green = new uint[length]; ramp.Blue = new uint[length]; for (int i = 0; i < ramp.Red.Length; ++i) { ramp.Red[i] = rampI.Red[i]; } for (int i = 0; i < ramp.Green.Length; ++i) { ramp.Green[i] = rampI.Green[i]; } for (int i = 0; i < ramp.Blue.Length; ++i) { ramp.Blue[i] = rampI.Blue[i]; } return(ramp); }
public static GammaRamp GetGammaRamp(IntPtr monitor) { unsafe { var internalRamp = _GetGammaRamp(monitor); var ramp = new GammaRamp { Red = new ushort[internalRamp->size], Green = new ushort[internalRamp->size], Blue = new ushort[internalRamp->size], Size = internalRamp->size }; for (uint i = 0; i < ramp.Size; i++) { ramp.Red[i] = internalRamp->red[i]; ramp.Green[i] = internalRamp->green[i]; ramp.Blue[i] = internalRamp->blue[i]; } return(ramp); } }
private static extern bool GetDeviceGammaRamp(IntPtr hDC, ref GammaRamp lpRamp);
/// <summary> /// Set the current gamma ramp to any ramp supplied. /// </summary> /// <param name="hDC"></param> /// <param name="ramp"></param> public static void SetGammaRamp(IntPtr hDC, ref GammaRamp ramp) { if (SetDeviceGammaRamp(hDC, ref ramp) == false) throw new InvalidOperationException("SetDeviceGammaRamp has failed"); }
public static extern void SetGammaRamp(IntPtr monitor, ref GammaRamp ramp);
public static void SetGammaRamp(Monitor monitor, GammaRamp ramp) { Imports.glfwSetGammaRamp(monitor, ramp); }
internal static extern bool SetDeviceGammaRamp(DeviceContextHandle deviceContextHandle, ref GammaRamp ramp);
public void SetGammaRamp(int swapChain, ref GammaRamp rampRef, bool calibrate) { _device.SetGammaRamp(swapChain, ref rampRef, calibrate); }
public static extern bool GetDeviceGammaRamp(IntPtr hMonitor, out GammaRamp ramp);
public static extern bool GetDeviceGammaRamp(IntPtr hdc, out GammaRamp lpRamp);
public static extern bool SetDeviceGammaRamp(IntPtr hdc, ref GammaRamp lpRamp);
internal static extern bool SetDeviceGammaRamp(DCHandle dcHandle, ref GammaRamp ramp);
private void SetGammaRamp(GammaRamp ramp) => NativeMethods.SetDeviceGammaRamp(Handle, ref ramp);
public static extern bool SetDeviceGammaRamp(IntPtr hMonitor, ref GammaRamp ramp);