static int GLW_MakeContext( PIXELFORMATDESCRIPTOR *pPFD )
{
//
// don't putz around with pixelformat if it's already set (e.g. this is a soft
// reset of the graphics system)
//
if ( !glw_state.pixelFormatSet )
{
int pixelformat;
//
// choose, set, and describe our desired pixel format. If we're
// using a minidriver then we need to bypass the GDI functions,
// otherwise use the GDI functions.
//
if (glw_state.nPendingPF)
pixelformat = glw_state.nPendingPF;
else
if ( ( pixelformat = GLW_ChoosePFD( glw_state.hDC, pPFD ) ) == 0 )
{
ri.Printf( PRINT_ALL, "...GLW_ChoosePFD failed\n");
return TRY_PFD_FAIL_SOFT;
}
ri.Printf( PRINT_DEVELOPER, "...PIXELFORMAT %d selected\n", pixelformat );
DescribePixelFormat( glw_state.hDC, pixelformat, sizeof( *pPFD ), pPFD );
if ( SetPixelFormat( glw_state.hDC, pixelformat, pPFD ) == FALSE )
{
ri.Printf( PRINT_ALL, "...SetPixelFormat failed\n", glw_state.hDC );
return TRY_PFD_FAIL_SOFT;
}
glw_state.pixelFormatSet = qtrue;
}
//
// startup the OpenGL subsystem by creating a context and making it current
//
if ( !glw_state.hGLRC )
{
if ( ( glw_state.hGLRC = qwglCreateContext( glw_state.hDC ) ) == 0 )
{
ri.Printf( PRINT_ALL, "...GL context creation failure\n" );
return TRY_PFD_FAIL_HARD;
}
ri.Printf( PRINT_DEVELOPER, "...GL context created\n" );
if ( !qwglMakeCurrent( glw_state.hDC, glw_state.hGLRC ) )
{
qwglDeleteContext( glw_state.hGLRC );
glw_state.hGLRC = NULL;
ri.Printf( PRINT_ALL, "...GL context creation currency failure\n" );
return TRY_PFD_FAIL_HARD;
}
ri.Printf( PRINT_DEVELOPER, "...GL context creation made current\n" );
}
return TRY_PFD_SUCCESS;
}
/*
** GLimp_SharedContext_Create
*/
void *GLimp_SharedContext_Create( void )
{
HGLRC ctx = qwglCreateContext( glw_state.hDC );
if( ctx ) {
qwglShareLists( glw_state.hGLRC, ctx );
}
return ctx;
}
/*
====================
FakeWndProc
Only used to get wglExtensions
====================
*/
LONG WINAPI FakeWndProc(
HWND hWnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam )
{
if( uMsg == WM_DESTROY )
{
PostQuitMessage( 0 );
}
if( uMsg != WM_CREATE )
{
return DefWindowProc( hWnd, uMsg, wParam, lParam );
}
const static PIXELFORMATDESCRIPTOR pfd =
{
sizeof( PIXELFORMATDESCRIPTOR ),
1,
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA,
24,
0, 0, 0, 0, 0, 0,
8, 0,
0, 0, 0, 0,
24, 8,
0,
PFD_MAIN_PLANE,
0,
0,
0,
0,
};
int pixelFormat;
HDC hDC;
HGLRC hGLRC;
hDC = GetDC( hWnd );
// Set up OpenGL
pixelFormat = ChoosePixelFormat( hDC, &pfd );
SetPixelFormat( hDC, pixelFormat, &pfd );
hGLRC = qwglCreateContext( hDC );
qwglMakeCurrent( hDC, hGLRC );
// free things
wglMakeCurrent( NULL, NULL );
wglDeleteContext( hGLRC );
ReleaseDC( hWnd, hDC );
return DefWindowProc( hWnd, uMsg, wParam, lParam );
}
/*
** GLimp_SharedContext_Create
*/
bool GLimp_SharedContext_Create( void **context, void **surface )
{
HGLRC ctx = qwglCreateContext( glw_state.hDC );
if( !ctx ) {
return false;
}
qwglShareLists( glw_state.hGLRC, ctx );
*context = ctx;
*surface = ( void * )1;
return true;
}
int CZWnd::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CWnd::OnCreate(lpCreateStruct) == -1)
return -1;
g_qeglobals.d_hwndZ = GetSafeHwnd();
m_dcZ = ::GetDC(GetSafeHwnd());
QEW_SetupPixelFormat(m_dcZ, false);
if ((m_hglrcZ = qwglCreateContext(m_dcZ )) == 0)
Error("wglCreateContext in CZWnd::OnCreate failed");
if (!qwglShareLists(g_qeglobals.d_hglrcBase, m_hglrcZ))
Error( "wglShareLists in CZWnd::OnCreate failed");
if (!qwglMakeCurrent(m_dcZ, m_hglrcZ))
Error ("wglMakeCurrent in CZWnd::OnCreate failed");
return 0;
}
static int 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
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
24, // 32-bit z-buffer
0, // no stencil buffer
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 );
pfd.cStencilBits = max( 0, r_stencilbits->integer );
if( pfd.cStencilBits != 0 )
glState.stencilEnabled = qtrue;
else
glState.stencilEnabled = qfalse;
/*
** set PFD_STEREO if necessary
*/
if( stereo->integer != 0 )
{
Com_Printf( "...attempting to use stereo\n" );
pfd.dwFlags |= PFD_STEREO;
glState.stereoEnabled = qtrue;
}
else
{
glState.stereoEnabled = qfalse;
}
/*
** figure out if we're running on a minidriver or not
*/
if( strstr( gl_driver->string, "opengl32" ) != 0 )
glw_state.minidriver = qfalse;
else
glw_state.minidriver = qtrue;
/*
** Get a DC for the specified window
*/
if( glw_state.hDC != NULL )
Com_Printf( "GLimp_Init() - non-NULL DC exists\n" );
if( ( glw_state.hDC = GetDC( glw_state.hWnd ) ) == NULL )
{
Com_Printf( "GLimp_Init() - GetDC failed\n" );
return qfalse;
}
if( glw_state.minidriver )
{
if( ( pixelformat = qwglChoosePixelFormat( glw_state.hDC, &pfd ) ) == 0 )
{
Com_Printf( "GLimp_Init() - qwglChoosePixelFormat failed\n" );
return qfalse;
}
if( qwglSetPixelFormat( glw_state.hDC, pixelformat, &pfd ) == FALSE )
{
Com_Printf( "GLimp_Init() - qwglSetPixelFormat failed\n" );
return qfalse;
}
qwglDescribePixelFormat( glw_state.hDC, pixelformat, sizeof( pfd ), &pfd );
}
else
{
if( ( pixelformat = ChoosePixelFormat( glw_state.hDC, &pfd ) ) == 0 )
{
Com_Printf( "GLimp_Init() - ChoosePixelFormat failed\n" );
return qfalse;
}
if( SetPixelFormat( glw_state.hDC, pixelformat, &pfd ) == FALSE )
{
Com_Printf( "GLimp_Init() - SetPixelFormat failed\n" );
return qfalse;
}
DescribePixelFormat( glw_state.hDC, pixelformat, sizeof( pfd ), &pfd );
if( !( pfd.dwFlags & PFD_GENERIC_ACCELERATED ) )
{
extern cvar_t *r_allow_software;
if( r_allow_software->integer )
glw_state.mcd_accelerated = qtrue;
else
glw_state.mcd_accelerated = qfalse;
}
else
{
glw_state.mcd_accelerated = qtrue;
}
}
/*
** report if stereo is desired but unavailable
*/
if( !( pfd.dwFlags & PFD_STEREO ) && ( stereo->integer != 0 ) )
{
Com_Printf( "...failed to select stereo pixel format\n" );
Cvar_SetValue( "cl_stereo", 0 );
glState.stereoEnabled = qfalse;
}
/*
** startup the OpenGL subsystem by creating a context and making
** it current
*/
if( ( glw_state.hGLRC = qwglCreateContext( glw_state.hDC ) ) == 0 )
{
Com_Printf( "GLimp_Init() - qwglCreateContext failed\n" );
goto fail;
}
if( !qwglMakeCurrent( glw_state.hDC, glw_state.hGLRC ) )
{
Com_Printf( "GLimp_Init() - qwglMakeCurrent failed\n" );
goto fail;
}
if( !VerifyDriver() )
{
Com_Printf( "GLimp_Init() - no hardware acceleration detected\n" );
goto fail;
}
/*
** print out PFD specifics
*/
Com_Printf( "GL PFD: color(%d-bits) Z(%d-bit) stencil(%d-bits)\n", ( int ) pfd.cColorBits, ( int ) pfd.cDepthBits, ( int )pfd.cStencilBits );
return qtrue;
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 qfalse;
}
static int 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
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
24, // 32-bit z-buffer
0, // no stencil buffer
0, // no auxiliary buffer
PFD_MAIN_PLANE, // main layer
0, // reserved
0, 0, 0 // layer masks ignored
};
int pixelformat;
if( r_stencilbits->integer == 8 || r_stencilbits->integer == 16 )
pfd.cStencilBits = r_stencilbits->integer;
/*
** set PFD_STEREO if necessary
*/
if( glConfig.stereoEnabled )
{
ri.Com_DPrintf( "...attempting to use stereo\n" );
pfd.dwFlags |= PFD_STEREO;
}
/*
** Get a DC for the specified window
*/
if( glw_state.hDC != NULL )
ri.Com_Printf( "GLimp_Init() - non-NULL DC exists\n" );
if( ( glw_state.hDC = GetDC( glw_state.hWnd ) ) == NULL )
{
ri.Com_Printf( "GLimp_Init() - GetDC failed\n" );
return false;
}
if( ( pixelformat = ChoosePixelFormat( glw_state.hDC, &pfd ) ) == 0 )
{
ri.Com_Printf( "GLimp_Init() - ChoosePixelFormat failed\n" );
return false;
}
if( SetPixelFormat( glw_state.hDC, pixelformat, &pfd ) == FALSE )
{
ri.Com_Printf( "GLimp_Init() - SetPixelFormat failed\n" );
return false;
}
DescribePixelFormat( glw_state.hDC, pixelformat, sizeof( pfd ), &pfd );
glConfig.stencilBits = pfd.cStencilBits;
/*
** report if stereo is desired but unavailable
*/
if( !( pfd.dwFlags & PFD_STEREO ) && glConfig.stereoEnabled )
{
ri.Com_Printf( "...failed to select stereo pixel format\n" );
glConfig.stereoEnabled = false;
}
/*
** startup the OpenGL subsystem by creating a context and making
** it current
*/
if( ( glw_state.hGLRC = qwglCreateContext( glw_state.hDC ) ) == 0 )
{
ri.Com_Printf( "GLimp_Init() - qwglCreateContext failed\n" );
goto fail;
}
if( !qwglMakeCurrent( glw_state.hDC, glw_state.hGLRC ) )
{
ri.Com_Printf( "GLimp_Init() - qwglMakeCurrent failed\n" );
goto fail;
}
/*
** print out PFD specifics
*/
ri.Com_Printf( "GL PFD: color(%d-bits) Z(%d-bit) stencil(%d-bits)\n", ( int ) pfd.cColorBits, ( int ) pfd.cDepthBits, ( int )pfd.cStencilBits );
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;
}
static int SetupGL(int colorbits, int depthbits, int stencilbits, int multisamples)
{
PIXELFORMATDESCRIPTOR pfd;
int pixelformat;
// create the main window
Win_Init();
if (colorbits == 0)
colorbits = 24;
if (depthbits == 0)
depthbits = colorbits > 16 ? 24 : 16;
if (depthbits < 24)
stencilbits = 0;
// choose pixel format
if (qwglChoosePixelFormatARB && multisamples > 1) {
int iAttributes[20];
UINT numFormats;
iAttributes[0] = WGL_DRAW_TO_WINDOW_ARB;
iAttributes[1] = TRUE;
iAttributes[2] = WGL_SUPPORT_OPENGL_ARB;
iAttributes[3] = TRUE;
iAttributes[4] = WGL_DOUBLE_BUFFER_ARB;
iAttributes[5] = TRUE;
iAttributes[6] = WGL_PIXEL_TYPE_ARB;
iAttributes[7] = WGL_TYPE_RGBA_ARB;
iAttributes[8] = WGL_COLOR_BITS_ARB;
iAttributes[9] = colorbits;
iAttributes[10] = WGL_DEPTH_BITS_ARB;
iAttributes[11] = depthbits;
iAttributes[12] = WGL_STENCIL_BITS_ARB;
iAttributes[13] = stencilbits;
iAttributes[14] = WGL_SAMPLE_BUFFERS_ARB;
iAttributes[15] = 1;
iAttributes[16] = WGL_SAMPLES_ARB;
iAttributes[17] = multisamples;
iAttributes[18] = 0;
iAttributes[19] = 0;
if (qwglChoosePixelFormatARB(win.dc, iAttributes, NULL, 1, &pixelformat, &numFormats) == FALSE) {
ReportLastError("wglChoosePixelFormatARB");
goto soft;
}
if (numFormats == 0) {
Com_EPrintf("No suitable OpenGL pixelformat found for %d multisamples\n", multisamples);
goto soft;
}
} else {
memset(&pfd, 0, sizeof(pfd));
pfd.nSize = sizeof(pfd);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = colorbits;
pfd.cDepthBits = depthbits;
pfd.cStencilBits = stencilbits;
pfd.iLayerType = PFD_MAIN_PLANE;
if (glw.minidriver) {
if ((pixelformat = qwglChoosePixelFormat(win.dc, &pfd)) == 0) {
ReportLastError("wglChoosePixelFormat");
goto soft;
}
} else {
if ((pixelformat = ChoosePixelFormat(win.dc, &pfd)) == 0) {
ReportLastError("ChoosePixelFormat");
goto soft;
}
}
}
// set pixel format
if (glw.minidriver) {
qwglDescribePixelFormat(win.dc, pixelformat, sizeof(pfd), &pfd);
ReportPixelFormat(pixelformat, &pfd);
if (qwglSetPixelFormat(win.dc, pixelformat, &pfd) == FALSE) {
ReportLastError("wglSetPixelFormat");
goto soft;
}
} else {
DescribePixelFormat(win.dc, pixelformat, sizeof(pfd), &pfd);
ReportPixelFormat(pixelformat, &pfd);
if (SetPixelFormat(win.dc, pixelformat, &pfd) == FALSE) {
ReportLastError("SetPixelFormat");
goto soft;
}
}
// check for software emulation
if (pfd.dwFlags & PFD_GENERIC_FORMAT) {
if (!gl_allow_software->integer) {
Com_EPrintf("No hardware OpenGL acceleration detected\n");
goto soft;
}
Com_WPrintf("...using software emulation\n");
} else if (pfd.dwFlags & PFD_GENERIC_ACCELERATED) {
Com_DPrintf("...MCD acceleration found\n");
win.flags |= QVF_ACCELERATED;
} else {
Com_DPrintf("...ICD acceleration found\n");
win.flags |= QVF_ACCELERATED;
}
// startup the OpenGL subsystem by creating a context and making it current
if ((glw.hGLRC = qwglCreateContext(win.dc)) == NULL) {
ReportLastError("wglCreateContext");
goto hard;
}
if (qwglMakeCurrent(win.dc, glw.hGLRC) == FALSE) {
ReportLastError("wglMakeCurrent");
qwglDeleteContext(glw.hGLRC);
glw.hGLRC = NULL;
goto hard;
}
return FAIL_OK;
soft:
// it failed, clean up
Win_Shutdown();
return FAIL_SOFT;
hard:
Win_Shutdown();
return FAIL_HARD;
}
static unsigned GetFakeWindowExtensions(void)
{
WNDCLASSEX wc;
PIXELFORMATDESCRIPTOR pfd;
int pixelformat;
HWND wnd;
HDC dc;
HGLRC rc;
unsigned extensions = 0;
memset(&wc, 0, sizeof(wc));
wc.cbSize = sizeof(wc);
wc.lpfnWndProc = DefWindowProc;
wc.hInstance = hGlobalInstance;
wc.lpszClassName = FAKE_WINDOW_CLASS;
if (!RegisterClassEx(&wc))
goto fail0;
wnd = CreateWindow(
FAKE_WINDOW_CLASS,
FAKE_WINDOW_NAME,
0,
0, 0, 0, 0,
NULL,
NULL,
hGlobalInstance,
NULL);
if (!wnd)
goto fail1;
if ((dc = GetDC(wnd)) == NULL)
goto fail2;
memset(&pfd, 0, sizeof(pfd));
pfd.nSize = sizeof(pfd);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 24;
pfd.cDepthBits = 24;
pfd.cStencilBits = 8;
pfd.iLayerType = PFD_MAIN_PLANE;
if (glw.minidriver) {
if ((pixelformat = qwglChoosePixelFormat(dc, &pfd)) == 0)
goto fail3;
if (qwglSetPixelFormat(dc, pixelformat, &pfd) == FALSE)
goto fail3;
} else {
if ((pixelformat = ChoosePixelFormat(dc, &pfd)) == 0)
goto fail3;
if (SetPixelFormat(dc, pixelformat, &pfd) == FALSE)
goto fail3;
}
if ((rc = qwglCreateContext(dc)) == NULL)
goto fail3;
if (qwglMakeCurrent(dc, rc) == FALSE)
goto fail4;
WGL_InitExtensions(QWGL_ARB_extensions_string);
if (!qwglGetExtensionsStringARB)
goto fail5;
extensions = WGL_ParseExtensionString(qwglGetExtensionsStringARB(dc));
if (extensions & QWGL_ARB_pixel_format) {
Com_Printf("...enabling WGL_ARB_pixel_format\n");
WGL_InitExtensions(QWGL_ARB_pixel_format);
}
fail5:
qwglMakeCurrent(NULL, NULL);
fail4:
qwglDeleteContext(rc);
fail3:
ReleaseDC(wnd, dc);
fail2:
DestroyWindow(wnd);
fail1:
UnregisterClass(FAKE_WINDOW_CLASS, hGlobalInstance);
fail0:
return extensions;
}
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;
}
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
24, // 24-bit color depth
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
24, // 32-bit z-buffer
8, // no stencil buffer
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->integer)
{
Com_Printf ( "...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 (Q_stristr( 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 )
Com_Printf ( "GLimp_Init() - non-NULL DC exists\n" );
if ( ( glw_state.hDC = GetDC( glw_state.hWnd ) ) == NULL )
{
PrintWinError("GLimp_Init() - GetDC", false);
return false;
}
if ( glw_state.minidriver )
{
if ( (pixelformat = qwglChoosePixelFormat( glw_state.hDC, &pfd)) == 0 )
{
PrintWinError("GLimp_Init() - wglChoosePixelFormat", false);
return false;
}
if ( qwglSetPixelFormat( glw_state.hDC, pixelformat, &pfd) == FALSE )
{
PrintWinError("GLimp_Init() - wglSetPixelFormat", false);
return false;
}
qwglDescribePixelFormat(glw_state.hDC, pixelformat, sizeof( pfd ), &pfd );
}
else
{
if ((pixelformat = ChoosePixelFormat(glw_state.hDC, &pfd)) == 0)
{
PrintWinError("GLimp_Init() - ChoosePixelFormat", false);
return false;
}
if (SetPixelFormat( glw_state.hDC, pixelformat, &pfd) == FALSE)
{
PrintWinError("GLimp_Init() - SetPixelFormat", false);
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->integer )
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 ) )
{
Com_Printf("...failed to select stereo pixel format\n");
Cvar_Set("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)
{
PrintWinError("GLimp_Init() - wglCreateContext", false);
return false;
}
if (!qwglMakeCurrent(glw_state.hDC, glw_state.hGLRC))
{
PrintWinError("GLimp_Init() - wglMakeCurrent", false);
return false;
}
if (!VerifyDriver())
{
Com_Error(ERR_FATAL, "GLimp_Init() - no hardware acceleration detected");
return false;
}
/*
** print out PFD specifics
*/
Com_Printf("GL PFD: Color(%dbits) Depth(%dbits) Stencil(%dbits)\n", (int)pfd.cColorBits, (int)pfd.cDepthBits, (int)pfd.cStencilBits);
{
char buffer[1024];
Q_strncpyz( buffer, (const char *)qglGetString( GL_RENDERER ), sizeof(buffer));
Q_strlwr( buffer );
gl_state.stencil = false;
if (strstr(buffer, "voodoo3"))
{
Com_Printf("... Voodoo3 has no stencil buffer\n");
}
else
{
if (pfd.cStencilBits > 0)
{
Com_Printf("... Using stencil buffer\n");
gl_state.stencil = true; // Stencil shadows -MrG
}
}
}
return true;
}
int CCamWnd::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CWnd::OnCreate(lpCreateStruct) == -1)
return -1;
g_qeglobals.d_hdcBase = GetDC()->m_hDC;
QEW_SetupPixelFormat(g_qeglobals.d_hdcBase, true);
if ((g_qeglobals.d_hglrcBase = qwglCreateContext(g_qeglobals.d_hdcBase)) == 0)
Error("wglCreateContext failed");
if (!qwglMakeCurrent(g_qeglobals.d_hdcBase, g_qeglobals.d_hglrcBase))
Error ("wglMakeCurrent failed");
//
// create GL font
//
HFONT hfont = ::CreateFont(
12, // logical height of font
6, // logical average character width
0, // angle of escapement
0, // base-line orientation angle
0, // font weight
0, // italic attribute flag
0, // underline attribute flag
0, // strikeout attribute flag
0, // character set identifier
0, // output precision
0, // clipping precision
0, // output quality
0, // pitch and family
"system font" // pointer to typeface name string
);
if (!hfont)
Error( "couldn't create font" );
::SelectObject(g_qeglobals.d_hdcBase, hfont);
if ((g_qeglobals.d_font_list = qglGenLists (256)) == 0)
Error( "couldn't create font dlists" );
// create the bitmap display lists
// we're making images of glyphs 0 thru 255
if (g_PrefsDlg.m_bBuggyICD)
{
if ( !qwglUseFontBitmaps (g_qeglobals.d_hdcBase, 1, 255, g_qeglobals.d_font_list-1) )
Error( "wglUseFontBitmaps faileD" );
}
else
{
if ( !qwglUseFontBitmaps (g_qeglobals.d_hdcBase, 1, 255, g_qeglobals.d_font_list) )
Error( "wglUseFontBitmaps faileD" );
}
// indicate start of glyph display lists
qglListBase (g_qeglobals.d_font_list);
// report OpenGL information
Sys_Printf ("GL_VENDOR: %s\n", qglGetString (GL_VENDOR));
Sys_Printf ("GL_RENDERER: %s\n", qglGetString (GL_RENDERER));
Sys_Printf ("GL_VERSION: %s\n", qglGetString (GL_VERSION));
Sys_Printf ("GL_EXTENSIONS: %s\n", qglGetString (GL_EXTENSIONS));
g_qeglobals.d_hwndCamera = GetSafeHwnd();
return 0;
}
/*
====================
GLW_InitDriver
Set the pixelformat for the window before it is
shown, and create the rendering context
====================
*/
static bool GLW_InitDriver( glimpParms_t parms ) {
PIXELFORMATDESCRIPTOR src =
{
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
0, 0, 0, 0, 0, 0, // color bits ignored
8, // 8 bit destination alpha
0, // shift bit ignored
0, // no accumulation buffer
0, 0, 0, 0, // accum bits ignored
24, // 24-bit z-buffer
8, // 8-bit stencil buffer
0, // no auxiliary buffer
PFD_MAIN_PLANE, // main layer
0, // reserved
0, 0, 0 // layer masks ignored
};
common->Printf( "Initializing OpenGL driver\n" );
//
// get a DC for our window if we don't already have one allocated
//
if ( win32.hDC == NULL ) {
common->Printf( "...getting DC: " );
if ( ( win32.hDC = GetDC( win32.hWnd ) ) == NULL ) {
common->Printf( "^3failed^0\n" );
return false;
}
common->Printf( "succeeded\n" );
}
// the multisample path uses the wgl
if ( wglChoosePixelFormatARB && parms.multiSamples > 1 ) {
int iAttributes[20];
FLOAT fAttributes[] = {0, 0};
UINT numFormats;
// FIXME: specify all the other stuff
iAttributes[0] = WGL_SAMPLE_BUFFERS_ARB;
iAttributes[1] = 1;
iAttributes[2] = WGL_SAMPLES_ARB;
iAttributes[3] = parms.multiSamples;
iAttributes[4] = WGL_DOUBLE_BUFFER_ARB;
iAttributes[5] = TRUE;
iAttributes[6] = WGL_STENCIL_BITS_ARB;
iAttributes[7] = 8;
iAttributes[8] = WGL_DEPTH_BITS_ARB;
iAttributes[9] = 24;
iAttributes[10] = WGL_RED_BITS_ARB;
iAttributes[11] = 8;
iAttributes[12] = WGL_BLUE_BITS_ARB;
iAttributes[13] = 8;
iAttributes[14] = WGL_GREEN_BITS_ARB;
iAttributes[15] = 8;
iAttributes[16] = WGL_ALPHA_BITS_ARB;
iAttributes[17] = 8;
iAttributes[18] = 0;
iAttributes[19] = 0;
wglChoosePixelFormatARB( win32.hDC, iAttributes, fAttributes, 1, &win32.pixelformat, &numFormats );
} else {
// this is the "classic" choose pixel format path
// eventually we may need to have more fallbacks, but for
// now, ask for everything
if ( parms.stereo ) {
common->Printf( "...attempting to use stereo\n" );
src.dwFlags |= PFD_STEREO;
}
//
// choose, set, and describe our desired pixel format. If we're
// using a minidriver then we need to bypass the GDI functions,
// otherwise use the GDI functions.
//
if ( ( win32.pixelformat = ChoosePixelFormat( win32.hDC, &src ) ) == 0 ) {
common->Printf( "...^3GLW_ChoosePFD failed^0\n");
return false;
}
common->Printf( "...PIXELFORMAT %d selected\n", win32.pixelformat );
}
// get the full info
DescribePixelFormat( win32.hDC, win32.pixelformat, sizeof( win32.pfd ), &win32.pfd );
glConfig.colorBits = win32.pfd.cColorBits;
glConfig.depthBits = win32.pfd.cDepthBits;
glConfig.stencilBits = win32.pfd.cStencilBits;
// XP seems to set this incorrectly
if ( !glConfig.stencilBits ) {
glConfig.stencilBits = 8;
}
// the same SetPixelFormat is used either way
if ( SetPixelFormat( win32.hDC, win32.pixelformat, &win32.pfd ) == FALSE ) {
common->Printf( "...^3SetPixelFormat failed^0\n", win32.hDC );
return false;
}
//
// startup the OpenGL subsystem by creating a context and making it current
//
common->Printf( "...creating GL context: " );
if ( ( win32.hGLRC = qwglCreateContext( win32.hDC ) ) == 0 ) {
common->Printf( "^3failed^0\n" );
return false;
}
common->Printf( "succeeded\n" );
common->Printf( "...making context current: " );
if ( !qwglMakeCurrent( win32.hDC, win32.hGLRC ) ) {
qwglDeleteContext( win32.hGLRC );
win32.hGLRC = NULL;
common->Printf( "^3failed^0\n" );
return false;
}
common->Printf( "succeeded\n" );
return true;
}