/*
** GLimp_UpdateGammaRamp
*/
bool GLimp_GetGammaRamp( size_t stride, unsigned short *psize, unsigned short *ramp )
{
unsigned short ramp256[3*256];
if( stride < 256 )
{
// only supports gamma ramps with 256 mappings per channel
return false;
}
if( qwglGetDeviceGammaRamp3DFX )
{
if( qwglGetDeviceGammaRamp3DFX( glw_state.hDC, ramp256 ) )
{
*psize = 256;
memcpy( ramp, ramp256, 256*sizeof(*ramp) );
memcpy( ramp+ stride, ramp256+ 256, 256*sizeof(*ramp) );
memcpy( ramp+2*stride, ramp256+2*256, 256*sizeof(*ramp) );
return true;
}
}
if( GetDeviceGammaRamp( glw_state.hDC, ramp256 ) )
{
*psize = 256;
memcpy( ramp, ramp256, 256*sizeof(*ramp) );
memcpy( ramp+ stride, ramp256+ 256, 256*sizeof(*ramp) );
memcpy( ramp+2*stride, ramp256+2*256, 256*sizeof(*ramp) );
return true;
}
return false;
}
/*
** WG_CheckHardwareGamma
**
** Determines if the underlying hardware supports the Win32 gamma correction API.
*/
void WG_CheckHardwareGamma( void ) {
HDC hDC;
glConfig.deviceSupportsGamma = qfalse;
if ( qwglSetDeviceGammaRamp3DFX ) {
glConfig.deviceSupportsGamma = qtrue;
hDC = GetDC( GetDesktopWindow() );
glConfig.deviceSupportsGamma = qwglGetDeviceGammaRamp3DFX( hDC, s_oldHardwareGamma );
ReleaseDC( GetDesktopWindow(), hDC );
return;
}
// non-3Dfx standalone drivers don't support gamma changes, period
if ( glConfig.driverType == GLDRV_STANDALONE ) {
return;
}
if ( !r_ignorehwgamma->integer ) {
hDC = GetDC( GetDesktopWindow() );
glConfig.deviceSupportsGamma = GetDeviceGammaRamp( hDC, s_oldHardwareGamma );
ReleaseDC( GetDesktopWindow(), hDC );
if ( glConfig.deviceSupportsGamma ) {
//
// do a sanity check on the gamma values
//
if ( ( HIBYTE( s_oldHardwareGamma[0][255] ) <= HIBYTE( s_oldHardwareGamma[0][0] ) ) ||
( HIBYTE( s_oldHardwareGamma[1][255] ) <= HIBYTE( s_oldHardwareGamma[1][0] ) ) ||
( HIBYTE( s_oldHardwareGamma[2][255] ) <= HIBYTE( s_oldHardwareGamma[2][0] ) ) ) {
glConfig.deviceSupportsGamma = qfalse;
ri.Printf( PRINT_WARNING, "WARNING: device has broken gamma support, generated gamma.dat\n" );
}
//
// make sure that we didn't have a prior crash in the game, and if so we need to
// restore the gamma values to at least a linear value
//
if ( ( HIBYTE( s_oldHardwareGamma[0][181] ) == 255 ) ) {
int g;
ri.Printf( PRINT_WARNING, "WARNING: suspicious gamma tables, using linear ramp for restoration\n" );
for ( g = 0; g < 255; g++ )
{
s_oldHardwareGamma[0][g] = g << 8;
s_oldHardwareGamma[1][g] = g << 8;
s_oldHardwareGamma[2][g] = g << 8;
}
}
}
}
}
/*
** GLimp_UpdateGammaRamp
*/
qboolean GLimp_GetGammaRamp( size_t stride, unsigned short *ramp )
{
if( qwglGetDeviceGammaRamp3DFX )
{
if( qwglGetDeviceGammaRamp3DFX( glw_state.hDC, ramp ) )
return qtrue;
}
if( GetDeviceGammaRamp( glw_state.hDC, ramp ) )
return qtrue;
return qfalse;
}
qboolean GLimp_InitGL (void)
{
PIXELFORMATDESCRIPTOR pfd =
{
sizeof(PIXELFORMATDESCRIPTOR), // size of this pfd
1, // version number
PFD_DRAW_TO_WINDOW | // support window
PFD_SUPPORT_OPENGL | // support OpenGL
PFD_DOUBLEBUFFER, // double buffered
PFD_TYPE_RGBA, // RGBA type
32, // 32-bit color depth // was 24
0, 0, 0, 0, 0, 0, // color bits ignored
0, // no alpha buffer
0, // shift bit ignored
0, // no accumulation buffer
0, 0, 0, 0, // accum bits ignored
//Knightmare 12/24/2001- stencil buffer
24, // 24-bit z-buffer, was 32
8, // 8-bit stencil buffer
//end Knightmare
0, // no auxiliary buffer
PFD_MAIN_PLANE, // main layer
0, // reserved
0, 0, 0 // layer masks ignored
};
int pixelformat;
cvar_t *stereo;
stereo = Cvar_Get( "cl_stereo", "0", 0 );
/*
** set PFD_STEREO if necessary
*/
if ( stereo->value != 0 )
{
VID_Printf( PRINT_ALL, "...attempting to use stereo\n" );
pfd.dwFlags |= PFD_STEREO;
gl_state.stereo_enabled = true;
}
else
{
gl_state.stereo_enabled = false;
}
/*
** figure out if we're running on a minidriver or not
*/
if ( strstr( gl_driver->string, "opengl32" ) != 0 )
glw_state.minidriver = false;
else
glw_state.minidriver = true;
/*
** Get a DC for the specified window
*/
if ( glw_state.hDC != NULL )
VID_Printf( PRINT_ALL, "GLimp_Init() - non-NULL DC exists\n" );
if ( ( glw_state.hDC = GetDC( glw_state.hWnd ) ) == NULL )
{
VID_Printf( PRINT_ALL, "GLimp_Init() - GetDC failed\n" );
return false;
}
if ( glw_state.minidriver )
{
if ( (pixelformat = qwglChoosePixelFormat( glw_state.hDC, &pfd)) == 0 )
{
VID_Printf (PRINT_ALL, "GLimp_Init() - qwglChoosePixelFormat failed\n");
return false;
}
if ( qwglSetPixelFormat( glw_state.hDC, pixelformat, &pfd) == FALSE )
{
VID_Printf (PRINT_ALL, "GLimp_Init() - qwglSetPixelFormat failed\n");
return false;
}
qwglDescribePixelFormat( glw_state.hDC, pixelformat, sizeof( pfd ), &pfd );
}
else
{
if ( ( pixelformat = ChoosePixelFormat( glw_state.hDC, &pfd)) == 0 )
{
VID_Printf (PRINT_ALL, "GLimp_Init() - ChoosePixelFormat failed\n");
return false;
}
if ( SetPixelFormat( glw_state.hDC, pixelformat, &pfd) == FALSE )
{
VID_Printf (PRINT_ALL, "GLimp_Init() - SetPixelFormat failed\n");
return false;
}
DescribePixelFormat( glw_state.hDC, pixelformat, sizeof( pfd ), &pfd );
if ( !( pfd.dwFlags & PFD_GENERIC_ACCELERATED ) )
{
extern cvar_t *gl_allow_software;
if ( gl_allow_software->value )
glw_state.mcd_accelerated = true;
else
glw_state.mcd_accelerated = false;
}
else
{
glw_state.mcd_accelerated = true;
}
}
/*
** report if stereo is desired but unavailable
*/
if ( !( pfd.dwFlags & PFD_STEREO ) && ( stereo->value != 0 ) )
{
VID_Printf( PRINT_ALL, "...failed to select stereo pixel format\n" );
Cvar_SetValue( "cl_stereo", 0 );
gl_state.stereo_enabled = false;
}
/*
** startup the OpenGL subsystem by creating a context and making
** it current
*/
if ( ( glw_state.hGLRC = qwglCreateContext( glw_state.hDC ) ) == 0 )
{
VID_Printf (PRINT_ALL, "GLimp_Init() - qwglCreateContext failed\n");
goto fail;
}
if ( !qwglMakeCurrent( glw_state.hDC, glw_state.hGLRC ) )
{
VID_Printf (PRINT_ALL, "GLimp_Init() - qwglMakeCurrent failed\n");
goto fail;
}
if ( !VerifyDriver() )
{
VID_Printf( PRINT_ALL, "GLimp_Init() - no hardware acceleration detected.\nPlease install drivers provided by your video card/GPU vendor.\n" );
goto fail;
}
/*
** print out PFD specifics
*/
VID_Printf( PRINT_ALL, "PIXELFORMAT: color(%d-bits) Z(%d-bit)\n", ( int ) pfd.cColorBits, ( int ) pfd.cDepthBits );
//Knightmare- Vic's hardware gamma stuff
if ( !r_ignorehwgamma->value )
{
if( qwglGetDeviceGammaRamp3DFX )
{
WORD newramp[3*256];
int j;
gl_state.gammaRamp = qwglGetDeviceGammaRamp3DFX ( glw_state.hDC, newramp );
for( j = 0; j < 256; j++ )
{
original_ramp[0][j] = newramp[j+0];
original_ramp[1][j] = newramp[j+256];
original_ramp[2][j] = newramp[j+512];
}
} else
{
gl_state.gammaRamp = GetDeviceGammaRamp ( glw_state.hDC, original_ramp );
}
}
else
{
gl_state.gammaRamp = false;
}
if (gl_state.gammaRamp)
vid_gamma->modified = true;
// moved these to GL_SetDefaultState
//gl_state.blend = false;
//gl_state.alphaTest = false;
//end Knightmare
//Knightmare- 12/24/2001- stecil buffer
{
char buffer[1024];
strcpy( buffer, qglGetString( GL_RENDERER ) );
strlwr( buffer );
if (strstr(buffer, "Voodoo3")) {
VID_Printf( PRINT_ALL, "... Voodoo3 has no stencil buffer\n" );
gl_config.have_stencil = false;
} else {
if (pfd.cStencilBits) {
VID_Printf( PRINT_ALL, "... Using stencil buffer\n" );
gl_config.have_stencil = true; // Stencil shadows - MrG
}
}
}
//if (pfd.cStencilBits)
// gl_config.have_stencil = true;
//end Knightmare
/* Moved to GL_SetDefaultState in r_glstate.c
// Vertex arrays
qglEnableClientState (GL_TEXTURE_COORD_ARRAY);
qglEnableClientState (GL_VERTEX_ARRAY);
qglEnableClientState (GL_COLOR_ARRAY);
qglTexCoordPointer (2, GL_FLOAT, sizeof(texCoordArray[0][0]), texCoordArray[0][0]);
qglVertexPointer (3, GL_FLOAT, sizeof(vertexArray[0]), vertexArray[0]);
qglColorPointer (4, GL_FLOAT, sizeof(colorArray[0]), colorArray[0]);
//gl_state.activetmu[0] = true;
// end vertex arrays
*/
return true;
fail:
if ( glw_state.hGLRC )
{
qwglDeleteContext( glw_state.hGLRC );
glw_state.hGLRC = NULL;
}
if ( glw_state.hDC )
{
ReleaseDC( glw_state.hWnd, glw_state.hDC );
glw_state.hDC = NULL;
}
return false;
}
