// Called from GLimp_SetGamma() and AppActivate()
static void UpdateGamma()
{
if (!gammaValid) return;
#if 0
DebugPrintf("updata gamma\n");
if (!SetDeviceGammaRamp(gl_hDC, newGamma))
DebugPrintf("Cannot update gamma!\n");
#else
SetDeviceGammaRamp(gl_hDC, newGamma);
#endif
}
static void Win_Activate( WPARAM wParam ) {
active_t active;
if( HIWORD( wParam ) ) {
// we don't want to act like we're active if we're minimized
active = ACT_MINIMIZED;
} else {
if( LOWORD( wParam ) ) {
active = ACT_ACTIVATED;
} else {
active = ACT_RESTORED;
}
}
CL_Activate( active );
if( win_noalttab->integer ) {
if( active == ACT_ACTIVATED ) {
Win_EnableAltTab();
} else {
Win_DisableAltTab();
}
}
if( win.flags & QVF_GAMMARAMP ) {
if( active == ACT_ACTIVATED ) {
SetDeviceGammaRamp( win.dc, win.gamma_cust );
} else {
SetDeviceGammaRamp( win.dc, win.gamma_orig );
}
}
if( win.flags & QVF_FULLSCREEN ) {
if( active == ACT_ACTIVATED ) {
ShowWindow( win.wnd, SW_RESTORE );
} else {
ShowWindow( win.wnd, SW_MINIMIZE );
}
if( vid_flip_on_switch->integer ) {
if( active == ACT_ACTIVATED ) {
ChangeDisplaySettings( &win.dm, CDS_FULLSCREEN );
} else {
ChangeDisplaySettings( NULL, 0 );
}
}
}
if( active == ACT_ACTIVATED ) {
SetForegroundWindow( win.wnd );
}
}
// Called from GLimp_Shutdown() and AppActivate()
static void RestoreGamma()
{
if (!gammaStored) return;
HWND hwnd = GetDesktopWindow();
HDC hdc = GetDC(hwnd);
#if 0
DebugPrintf("restore gamma\n");
if (!SetDeviceGammaRamp(hdc, gammaRamp))
DebugPrintf("Cannot restore gamma!\n");
#else
SetDeviceGammaRamp(hdc, gammaRamp);
#endif
ReleaseDC(hwnd, hdc);
}
void SDLWindow::setGammaRamp(const Array<uint16>& gammaRamp) {
alwaysAssertM(gammaRamp.size() >= 256, "Gamma ramp must have at least 256 entries");
Log* debugLog = Log::common();
uint16* ptr = const_cast<uint16*>(gammaRamp.getCArray());
#ifdef WIN32
// On windows, use the more reliable SetDeviceGammaRamp function.
// It requires separate RGB gamma ramps.
uint16 wptr[3 * 256];
for (int i = 0; i < 256; ++i) {
wptr[i] = wptr[i + 256] = wptr[i + 512] = ptr[i];
}
BOOL success = SetDeviceGammaRamp(wglGetCurrentDC(), wptr);
#else
bool success = (SDL_SetGammaRamp(ptr, ptr, ptr) != -1);
#endif
if (! success) {
if (debugLog) {debugLog->println("Error setting gamma ramp!");}
#ifdef WIN32
debugAssertM(false, "Failed to set gamma ramp");
#else
if (debugLog) {debugLog->println(SDL_GetError());}
debugAssertM(false, SDL_GetError());
#endif
}
}
/*
** WG_GetOldGammaRamp
**
*/
void WG_GetOldGammaRamp(void)
{
HDC hDC;
hDC = GetDC(GetDesktopWindow());
GetDeviceGammaRamp(hDC, s_oldHardwareGamma);
ReleaseDC(GetDesktopWindow(), hDC);
/*
** GLimp_SetGamma
**
*/
void GLimp_SetGamma(unsigned char red[256], unsigned char green[256], unsigned char blue[256]) {
unsigned short table[3][256];
int i;
if (!glw_state.hDC) {
return;
}
for (i = 0; i < 256; i++) {
table[0][i] = (((unsigned short) red[i]) << 8) | red[i];
table[1][i] = (((unsigned short) green[i]) << 8) | green[i];
table[2][i] = (((unsigned short) blue[i]) << 8) | blue[i];
}
if (!SetDeviceGammaRamp(glw_state.hDC, table)) {
common->Printf("WARNING: SetDeviceGammaRamp failed.\n");
}
}
/*
** GLimp_SetGammaRamp
*/
void GLimp_SetGammaRamp( size_t stride, unsigned short *ramp )
{
if( qwglGetDeviceGammaRamp3DFX )
qwglSetDeviceGammaRamp3DFX( glw_state.hDC, ramp );
else
SetDeviceGammaRamp( glw_state.hDC, ramp );
}
void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
{
HDC dc;
WORD values[768];
DISPLAY_DEVICE display;
if (ramp->size != 256)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Win32: Gamma ramp size must be 256");
return;
}
memcpy(values + 0, ramp->red, 256 * sizeof(unsigned short));
memcpy(values + 256, ramp->green, 256 * sizeof(unsigned short));
memcpy(values + 512, ramp->blue, 256 * sizeof(unsigned short));
ZeroMemory(&display, sizeof(DISPLAY_DEVICE));
display.cb = sizeof(DISPLAY_DEVICE);
EnumDisplayDevices(monitor->win32.name, 0, &display, 0);
dc = CreateDC(L"DISPLAY", display.DeviceString, NULL, NULL);
SetDeviceGammaRamp(dc, values);
DeleteDC(dc);
}
int DIB_SetGammaRamp(_THIS, Uint16 *ramp)
{
#ifdef NO_GAMMA_SUPPORT
SDL_SetError("SDL compiled without gamma ramp support");
return -1;
#else
HDC hdc;
BOOL succeeded;
/* Set the ramp for the display */
if ( ! gamma_saved ) {
gamma_saved = (WORD *)malloc(3*256*sizeof(*gamma_saved));
if ( ! gamma_saved ) {
SDL_OutOfMemory();
return -1;
}
hdc = GetDC(SDL_Window);
GetDeviceGammaRamp(hdc, gamma_saved);
ReleaseDC(SDL_Window, hdc);
}
if ( SDL_GetAppState() & SDL_APPINPUTFOCUS ) {
hdc = GetDC(SDL_Window);
succeeded = SetDeviceGammaRamp(hdc, ramp);
ReleaseDC(SDL_Window, hdc);
} else {
succeeded = TRUE;
}
return succeeded ? 0 : -1;
#endif /* !NO_GAMMA_SUPPORT */
}
BOOL CGammaRamp::SetBrightness(WORD wBrightness, HDC hDC)
{
BOOL bReturn = FALSE;
HDC hGammaDC = hDC;
if (hDC == NULL)
hGammaDC = GetDC(NULL);
if (hGammaDC != NULL)
{
WORD GammaArray[3][256];
for (int iIndex = 0; iIndex < 256; iIndex++)
{
int iArrayValue = iIndex * (wBrightness + 128);
if (iArrayValue > 65535)
iArrayValue = 65535;
GammaArray[0][iIndex] =
GammaArray[1][iIndex] =
GammaArray[2][iIndex] = (WORD)iArrayValue;
}
bReturn = SetDeviceGammaRamp(hGammaDC, GammaArray);
}
if (hDC == NULL)
ReleaseDC(NULL, hGammaDC);
return bReturn;
}
/*
** GLimp_SetGamma
**
** This routine should only be called if glConfig.deviceSupportsGamma is TRUE
*/
void GLimp_SetGamma( unsigned char red[256], unsigned char green[256], unsigned char blue[256] ) {
unsigned short table[3][256];
int i, j;
int ret;
OSVERSIONINFO vinfo;
if ( !glConfig.deviceSupportsGamma || r_ignorehwgamma->integer || !glw_state.hDC ) {
return;
}
//mapGammaMax();
for ( i = 0; i < 256; i++ ) {
table[0][i] = ( ( ( unsigned short ) red[i] ) << 8 ) | red[i];
table[1][i] = ( ( ( unsigned short ) green[i] ) << 8 ) | green[i];
table[2][i] = ( ( ( unsigned short ) blue[i] ) << 8 ) | blue[i];
}
// Win2K puts this odd restriction on gamma ramps...
vinfo.dwOSVersionInfoSize = sizeof(vinfo);
GetVersionEx( &vinfo );
if ( vinfo.dwMajorVersion == 5 && vinfo.dwPlatformId == VER_PLATFORM_WIN32_NT ) {
Com_DPrintf( "performing W2K gamma clamp.\n" );
for ( j = 0 ; j < 3 ; j++ ) {
for ( i = 0 ; i < 128 ; i++ ) {
if ( table[j][i] > ( (128+i) << 8 ) ) {
table[j][i] = (128+i) << 8;
}
}
if ( table[j][127] > 254<<8 ) {
table[j][127] = 254<<8;
}
}
} else {
Com_DPrintf( "skipping W2K gamma clamp.\n" );
}
// enforce constantly increasing
for ( j = 0 ; j < 3 ; j++ ) {
for ( i = 1 ; i < 256 ; i++ ) {
if ( table[j][i] < table[j][i-1] ) {
table[j][i] = table[j][i-1];
}
}
}
if ( qwglSetDeviceGammaRamp3DFX )
{
qwglSetDeviceGammaRamp3DFX( glw_state.hDC, table );
}
else
{
ret = SetDeviceGammaRamp( glw_state.hDC, table );
if ( !ret ) {
Com_Printf( "SetDeviceGammaRamp failed.\n" );
}
}
}
void SWimp_RestoreHWGamma()
{
if( sw_state.hw_gamma_supported )
{
HDC desktop_hdc = GetDC( GetDesktopWindow() );
SetDeviceGammaRamp( desktop_hdc, old_gamma );
ReleaseDC( GetDesktopWindow(), desktop_hdc );
}
}
static void GLW_RestoreGamma()
{
if (!glConfig.deviceSupportsGamma)
return;
HDC hDC = GetDC( GetDesktopWindow() );
SetDeviceGammaRamp( hDC, s_oldHardwareGamma );
ReleaseDC( GetDesktopWindow(), hDC );
}
static void APIENTRY SetGammaRamp (Uint16 *redtable, Uint16 *greentable, Uint16 *bluetable)
#endif
{
#ifndef unix
SetDeviceGammaRamp(m_hDC, ramp);
#else
SDL_SetGammaRamp(redtable, greentable, bluetable);
#endif
}
/*
** VG_SetGamma
**
** This routine should only be called if deviceSupportsGamma is TRUE
*/
void VG_SetGamma( unsigned char red[256], unsigned char green[256], unsigned char blue[256] )
{
unsigned short table[3][256];
int i, j;
int ret;
OSVERSIONINFO vinfo;
HDC hDC;
hDC = GetDC(GetDesktopWindow());
if (!deviceSupportsGamma || !hDC)
return;
for ( i = 0; i < 256; i++ ) {
table[0][i] = ( ( ( unsigned short ) red[i] ) << 8 ) | red[i];
table[1][i] = ( ( ( unsigned short ) green[i] ) << 8 ) | green[i];
table[2][i] = ( ( ( unsigned short ) blue[i] ) << 8 ) | blue[i];
}
// Win2K puts this odd restriction on gamma ramps...
vinfo.dwOSVersionInfoSize = sizeof(vinfo);
GetVersionEx( &vinfo );
if ( vinfo.dwMajorVersion == 5 && vinfo.dwPlatformId == VER_PLATFORM_WIN32_NT )
{
ri.Con_Printf(PRINT_DEVELOPER, "performing Windows 2000 gamma clamp.\n");
for ( j = 0 ; j < 3 ; j++ ) {
for ( i = 0 ; i < 128 ; i++ ) {
if ( table[j][i] > ( (128+i) << 8 ) ) {
table[j][i] = (128+i) << 8;
}
}
if ( table[j][127] > 254<<8 ) {
table[j][127] = 254<<8;
}
}
}
else
{
ri.Con_Printf(PRINT_DEVELOPER, "skipping Windows 2000 gamma clamp.\n");
}
// enforce constantly increasing
for ( j = 0 ; j < 3 ; j++ ) {
for ( i = 1 ; i < 256 ; i++ ) {
if ( table[j][i] < table[j][i-1] ) {
table[j][i] = table[j][i-1];
}
}
}
ret = SetDeviceGammaRamp( hDC, table );
if (!ret)
ri.Con_Printf(PRINT_ALL, "SetDeviceGammaRamp failed.\n");
ReleaseDC( GetDesktopWindow(), hDC );
}
void setGammaRamp(JNIEnv * env, jobject gammaRampBuffer) {
HDC screenDC;
WORD *gammaRamp = (WORD *)(*env)->GetDirectBufferAddress(env, gammaRampBuffer);
screenDC = GetDC(NULL);
if (SetDeviceGammaRamp(screenDC, gammaRamp) == FALSE) {
throwException(env, "Failed to set device gamma.");
}
ReleaseDC(NULL, screenDC);
}
void DIB_SwapGamma(_THIS)
{
#ifndef NO_GAMMA_SUPPORT
HDC hdc;
if ( gamma_saved ) {
hdc = GetDC(SDL_Window);
if ( SDL_GetAppState() & SDL_APPINPUTFOCUS ) {
/* About to leave active state, restore gamma */
SetDeviceGammaRamp(hdc, gamma_saved);
} else {
/* About to enter active state, set game gamma */
GetDeviceGammaRamp(hdc, gamma_saved);
SetDeviceGammaRamp(hdc, this->gamma);
}
ReleaseDC(SDL_Window, hdc);
}
#endif /* !NO_GAMMA_SUPPORT */
}
// Standard destructor
GLDriver::~GLDriver()
{
Trace("Shutting down");
if(Config::getBoolValue("UseHardwareGamma"))
SetDeviceGammaRamp(hdc, &oldGamma);
#if 0
wglFreeMemoryNV(mem);
#endif
}
/*
** WG_RestoreGamma
*/
void WG_RestoreGamma( void )
{
if ( glConfig.deviceSupportsGamma )
{
HDC hDC;
hDC = GetDC( GetDesktopWindow() );
SetDeviceGammaRamp( hDC, s_oldHardwareGamma );
ReleaseDC( GetDesktopWindow(), hDC );
}
}
HRESULT WINAPI IWineD3DBaseSwapChainImpl_SetGammaRamp(IWineD3DSwapChain *iface, DWORD Flags, CONST WINED3DGAMMARAMP *pRamp){
IWineD3DSwapChainImpl *This = (IWineD3DSwapChainImpl *)iface;
HDC hDC;
TRACE("(%p) : pRamp@%p flags(%d)\n", This, pRamp, Flags);
hDC = GetDC(This->device_window);
SetDeviceGammaRamp(hDC, (LPVOID)pRamp);
ReleaseDC(This->device_window, hDC);
return WINED3D_OK;
}
void VID_RestoreGamma() // jitgamma
{
if (gammaramp_supported)
{
HDC hdc;
hdc = GetDC (GetDesktopWindow());
SetDeviceGammaRamp (hdc, &desktop_gammaramp[0][0]);
ReleaseDC (GetDesktopWindow(), hdc);
}
}
// This routine does all OS specific shutdown procedures for the OpenGL
// subsystem.
void GLimp_Shutdown() {
const char* success[] = { "failed", "success" };
common->Printf( "Shutting down OpenGL subsystem\n" );
// delete display lists
GLW_DeleteDefaultLists();
// restore gamma.
if ( glConfig.deviceSupportsGamma ) {
HDC hDC = GetDC( GetDesktopWindow() );
SetDeviceGammaRamp( hDC, s_oldHardwareGamma );
ReleaseDC( GetDesktopWindow(), hDC );
glConfig.deviceSupportsGamma = false;
}
// set current context to NULL
int retVal = wglMakeCurrent( NULL, NULL ) != 0;
common->Printf( "...wglMakeCurrent( NULL, NULL ): %s\n", success[ retVal ] );
// delete HGLRC
if ( baseRC ) {
retVal = wglDeleteContext( baseRC ) != 0;
common->Printf( "...deleting GL context: %s\n", success[ retVal ] );
baseRC = NULL;
}
// release DC
if ( maindc ) {
retVal = ReleaseDC( GMainWindow, maindc ) != 0;
common->Printf( "...releasing DC: %s\n", success[ retVal ] );
maindc = NULL;
}
// destroy window
if ( GMainWindow ) {
common->Printf( "...destroying window\n" );
ShowWindow( GMainWindow, SW_HIDE );
DestroyWindow( GMainWindow );
GMainWindow = NULL;
pixelFormatSet = false;
}
// reset display settings
if ( cdsFullscreen ) {
common->Printf( "...resetting display\n" );
ChangeDisplaySettings( 0, 0 );
cdsFullscreen = false;
}
Com_Memset( &glConfig, 0, sizeof ( glConfig ) );
Com_Memset( &glState, 0, sizeof ( glState ) );
}
/*
** VG_RestoreGamma
*/
void VG_RestoreGamma( void )
{
HDC hDC;
hDC = GetDC( GetDesktopWindow() );
if (deviceSupportsGamma)
{
SetDeviceGammaRamp(hDC, oldHardwareGamma);
}
ReleaseDC(GetDesktopWindow(), hDC);
}
static int w32gdi_restore(void)
{
/* Restore gamma ramps */
if( (!state.hDC)||(!state.saved_ramps) ){
LOG(LOGERR,_("No device context or ramp."));
return RET_FUN_FAILED;
}
if( !SetDeviceGammaRamp(state.hDC, state.saved_ramps) ){
LOG(LOGERR,_("Unable to restore gamma ramps."));
return RET_FUN_FAILED;
}
return RET_FUN_SUCCESS;
}
/*
** WG_RestoreGamma
*/
void WG_RestoreGamma(void) {
HDC hDC;
// if we never read in a reasonable looking
// table, don't write it out
if (s_oldHardwareGamma[0][255] == 0) {
return;
}
hDC = GetDC(GetDesktopWindow());
SetDeviceGammaRamp(hDC, s_oldHardwareGamma);
ReleaseDC(GetDesktopWindow(), hDC);
}
/*
** GLimp_SetGamma
**
** This routine should only be called if glConfig.deviceSupportsGamma is TRUE
*/
void GLimp_SetGamma( unsigned char red[256], unsigned char green[256], unsigned char blue[256] ) {
unsigned short table[3][256];
int i, j;
int ret;
OSVERSIONINFO vinfo;
if ( !glConfig.deviceSupportsGamma || r_gammamethod->integer != GAMMA_HARDWARE || !glw_state.hDC ) {
return;
}
for ( i = 0; i < 256; i++ ) {
table[0][i] = ( ( ( unsigned short ) red[i] ) << 8 ) | red[i];
table[1][i] = ( ( ( unsigned short ) green[i] ) << 8 ) | green[i];
table[2][i] = ( ( ( unsigned short ) blue[i] ) << 8 ) | blue[i];
}
// Win2K puts this odd restriction on gamma ramps...
// https://github.com/JACoders/OpenJK/commit/43322f7f25dfce966bdbed7376c698cddf796284
vinfo.dwOSVersionInfoSize = sizeof(vinfo);
GetVersionEx( &vinfo );
if ( vinfo.dwMajorVersion >= 5 && vinfo.dwPlatformId == VER_PLATFORM_WIN32_NT ) {
Com_DPrintf( "performing W2K gamma clamp.\n" );
for ( j = 0 ; j < 3 ; j++ ) {
for ( i = 0 ; i < 128 ; i++ ) {
if ( table[j][i] > ( (128+i) << 8 ) ) {
table[j][i] = (128+i) << 8;
}
}
if ( table[j][127] > 254<<8 ) {
table[j][127] = 254<<8;
}
}
} else {
Com_DPrintf( "skipping gamma clamp.\n" );
}
// enforce constantly increasing
for ( j = 0 ; j < 3 ; j++ ) {
for ( i = 1 ; i < 256 ; i++ ) {
if ( table[j][i] < table[j][i-1] ) {
table[j][i] = table[j][i-1];
}
}
}
ret = SetDeviceGammaRamp( glw_state.hDC, table );
if ( !ret ) {
Com_Printf( "SetDeviceGammaRamp failed.\n" );
}
}
void _stdcall ProxyDevice::SetGammaRamp(DWORD a, const D3DGAMMARAMP *b)
{
IDirect3DSwapChain9 *sc;
D3DPRESENT_PARAMETERS pp;
realDevice->GetSwapChain(0, &sc);
sc->GetPresentParameters(&pp);
sc->Release();
if(pp.Windowed)
SetDeviceGammaRamp(GetDC(pp.hDeviceWindow), (void*)b);
else
realDevice->SetGammaRamp(0, a, b);
}
/*
** WG_RestoreGamma
*/
void WG_RestoreGamma( void ) {
if ( glConfig.deviceSupportsGamma ) {
if ( qwglSetDeviceGammaRamp3DFX ) {
qwglSetDeviceGammaRamp3DFX( glw_state.hDC, s_oldHardwareGamma );
} else
{
HDC hDC;
hDC = GetDC( GetDesktopWindow() );
SetDeviceGammaRamp( hDC, s_oldHardwareGamma );
ReleaseDC( GetDesktopWindow(), hDC );
}
}
}
/*
============
VID_UpdateGamma
============
*/
void VID_UpdateGamma( const byte *table ) {
WORD v;
int i;
if( win.flags & QVF_GAMMARAMP ) {
for( i = 0; i < 256; i++ ) {
v = table[i] << 8;
win.gamma_cust[0][i] = v;
win.gamma_cust[1][i] = v;
win.gamma_cust[2][i] = v;
}
SetDeviceGammaRamp( win.dc, win.gamma_cust );
}
}
/*
========================
GLimp_RestoreGamma
========================
*/
static void GLimp_RestoreGamma() {
HDC hDC;
BOOL success;
// if we never read in a reasonable looking
// table, don't write it out
if ( win32.oldHardwareGamma[0][255] == 0 ) {
return;
}
hDC = GetDC( GetDesktopWindow() );
success = SetDeviceGammaRamp( hDC, win32.oldHardwareGamma );
common->DPrintf ( "...restoring hardware gamma: %s\n", success ? "success" : "failed" );
ReleaseDC( GetDesktopWindow(), hDC );
}
void SWimp_SetHWGamma()
{
unsigned short gamma[3][256];
int i;
for( i= 0; i< 256; i++ )
{
gamma[0][i]=
gamma[1][i]=
gamma[2][i]= sw_state.gammatable[i]<<8;
}
if( SetDeviceGammaRamp( sww_state.hDC, gamma ) == FALSE )
printf( "hw gamma change error!\n" );
}
