win_glimp.c File Reference

#include <assert.h>
#include "../renderer/tr_local.h"
#include "../qcommon/qcommon.h"
#include "resource.h"
#include "glw_win.h"
#include "win_local.h"

Include dependency graph for win_glimp.c:

Go to the source code of this file.

Defines
#define	MAX_PFDS   256
#define	OSR2_BUILD_NUMBER   1111
#define	TRY_PFD_FAIL_HARD   2
#define	TRY_PFD_FAIL_SOFT   1
#define	TRY_PFD_SUCCESS   0
#define	WINDOW_CLASS_NAME   "Quake 3: Arena"
#define	WINDOW_STYLE   (WS_OVERLAPPED|WS_BORDER|WS_CAPTION|WS_VISIBLE)
Enumerations
enum	rserr_t { RSERR_OK, RSERR_INVALID_FULLSCREEN, RSERR_INVALID_MODE, RSERR_UNKNOWN }
Functions
void	GLimp_EndFrame (void)
void	GLimp_FrontEndSleep (void)
void	GLimp_Init (void)
void	GLimp_LogComment (char *comment)
void *	GLimp_RendererSleep (void)
void	GLimp_RenderThreadWrapper (void)
void	GLimp_Shutdown (void)
qboolean	GLimp_SpawnRenderThread (void(*function)(void))
void	GLimp_WakeRenderer (void *data)
qboolean	GLW_CheckOSVersion (void)
int	GLW_ChoosePFD (HDC hDC, PIXELFORMATDESCRIPTOR *pPFD)
void	GLW_CreatePFD (PIXELFORMATDESCRIPTOR *pPFD, int colorbits, int depthbits, int stencilbits, qboolean stereo)
qboolean	GLW_CreateWindow (const char *drivername, int width, int height, int colorbits, qboolean cdsFullscreen)
qboolean	GLW_InitDriver (const char *drivername, int colorbits)
void	GLW_InitExtensions (void)
qboolean	GLW_LoadOpenGL (const char *drivername)
int	GLW_MakeContext (PIXELFORMATDESCRIPTOR *pPFD)
rserr_t	GLW_SetMode (const char *drivername, int mode, int colorbits, qboolean cdsFullscreen)
qboolean	GLW_StartDriverAndSetMode (const char *drivername, int mode, int colorbits, qboolean cdsFullscreen)
void	GLW_StartOpenGL (void)
void	PrintCDSError (int value)
void	QGL_EnableLogging (qboolean enable)
qboolean	QGL_Init (const char *dllname)
void	QGL_Shutdown (void)
void	WG_CheckHardwareGamma (void)
void	WG_RestoreGamma (void)
Variables
void(*	glimpRenderThread )(void)
glwstate_t	glw_state
cvar_t *	r_allowSoftwareGL
cvar_t *	r_maskMinidriver
HANDLE	renderActiveEvent
HANDLE	renderCommandsEvent
HANDLE	renderCompletedEvent
HANDLE	renderThreadHandle
int	renderThreadId
qboolean	s_classRegistered = qfalse
void *	smpData
int	wglErrors

---

Define Documentation

#define MAX_PFDS   256

Definition at line 118 of file win_glimp.c. Referenced by GLW_ChoosePFD().

#define OSR2_BUILD_NUMBER   1111

#define TRY_PFD_FAIL_HARD   2

Definition at line 58 of file win_glimp.c.

#define TRY_PFD_FAIL_SOFT   1

Definition at line 57 of file win_glimp.c.

#define TRY_PFD_SUCCESS   0

Definition at line 56 of file win_glimp.c.

#define WINDOW_CLASS_NAME   "Quake 3: Arena"

Definition at line 60 of file win_glimp.c.

#define WINDOW_STYLE   (WS_OVERLAPPED|WS_BORDER|WS_CAPTION|WS_VISIBLE)

Definition at line 576 of file win_glimp.c. Referenced by GLW_CreateWindow().

---

Enumeration Type Documentation

enum rserr_t

Enumeration values: RSERR_OK  RSERR_INVALID_FULLSCREEN  RSERR_INVALID_MODE  RSERR_UNKNOWN  Definition at line 47 of file win_glimp.c. { RSERR_OK, RSERR_INVALID_FULLSCREEN, RSERR_INVALID_MODE, RSERR_UNKNOWN } rserr_t;

---

Function Documentation

void GLimp_EndFrame (  void   )

Definition at line 1244 of file win_glimp.c. References glwstate_t::bufferSwapCount, Com_Printf(), glconfig_t::driverType, ERR_FATAL, glConfig, glwstate_t::glPauseCount, GLSTAMP, glw_state, glwstate_t::hDC, cvar_s::integer, cvar_s::modified, OSX_GLContextClearCurrent, OSX_GLContextIsCurrent, OSX_GLContextSetCurrent, Q_stricmp(), QGL_EnableLogging(), QGLCheckError(), qwglSwapIntervalEXT, r_drawBuffer, r_enablerender, r_logFile, r_swapInterval, ri, glconfig_t::stereoEnabled, and cvar_s::string. { // // swapinterval stuff // if ( r_swapInterval->modified ) { r_swapInterval->modified = qfalse; if ( !glConfig.stereoEnabled ) { // why? if ( qwglSwapIntervalEXT ) { qwglSwapIntervalEXT( r_swapInterval->integer ); } } } // don't flip if drawing to front buffer if ( Q_stricmp( r_drawBuffer->string, "GL_FRONT" ) != 0 ) { if ( glConfig.driverType > GLDRV_ICD ) { if ( !qwglSwapBuffers( glw_state.hDC ) ) { ri.Error( ERR_FATAL, "GLimp_EndFrame() - SwapBuffers() failed!\n" ); } } else { SwapBuffers( glw_state.hDC ); } } // check logging QGL_EnableLogging( r_logFile->integer ); }

Here is the call graph for this function:

void GLimp_FrontEndSleep (  void   )

Definition at line 1637 of file win_glimp.c. References Com_Printf(), GLSTAMP, glw_state, glwstate_t::hDC, glwstate_t::hGLRC, INFINITE, mainThreadCondition, OSX_GLContextSetCurrent, renderCompletedEvent, smpMutex, and wglErrors. { WaitForSingleObject( renderCompletedEvent, INFINITE ); if ( !qwglMakeCurrent( glw_state.hDC, glw_state.hGLRC ) ) { wglErrors++; } }

Here is the call graph for this function:

void GLimp_Init (  void   )

Definition at line 1350 of file win_glimp.c. References BOOL, Cmd_AddCommand(), CVAR_ARCHIVE, refimport_t::Cvar_Get, CVAR_LATCH, refimport_t::Cvar_Set, cvar_t, glconfig_t::deviceSupportsGamma, ERR_FATAL, glconfig_t::extensions_string, free(), g_wv, glConfig, GLimp_SetMode(), GLImp_Toggle_Renderer_f(), GLW_CheckOSVersion(), GLW_InitExtensions(), GLW_StartOpenGL(), glw_state, glconfig_t::hardwareType, WinVars_t::hInstance, cvar_s::integer, malloc(), memset(), OSX_GLContextClearCurrent, PRINT_ALL, Q_stricmp(), Q_strlwr(), Q_strncpyz(), qfalse, qglGetString, qtrue, r_allowSoftwareGL, r_enablerender, r_fullscreen, r_maskMinidriver, glconfig_t::renderer_string, ri, sscanf(), strcpy(), cvar_s::string, strlen(), strstr(), Sys_QueryVideoMemory(), Sys_StoreGammaTables(), glconfig_t::vendor_string, glconfig_t::version_string, WG_CheckHardwareGamma(), and glwstate_t::wndproc. { char buf[1024]; cvar_t *lastValidRenderer = ri.Cvar_Get( "r_lastValidRenderer", "(uninitialized)", CVAR_ARCHIVE ); cvar_t *cv; ri.Printf( PRINT_ALL, "Initializing OpenGL subsystem\n" ); // // check OS version to see if we can do fullscreen display changes // if ( !GLW_CheckOSVersion() ) { ri.Error( ERR_FATAL, "GLimp_Init() - incorrect operating system\n" ); } // save off hInstance and wndproc cv = ri.Cvar_Get( "win_hinstance", "", 0 ); sscanf( cv->string, "%i", (int *)&g_wv.hInstance ); cv = ri.Cvar_Get( "win_wndproc", "", 0 ); sscanf( cv->string, "%i", (int *)&glw_state.wndproc ); r_allowSoftwareGL = ri.Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH ); r_maskMinidriver = ri.Cvar_Get( "r_maskMinidriver", "0", CVAR_LATCH ); // load appropriate DLL and initialize subsystem GLW_StartOpenGL(); // get our config strings Q_strncpyz( glConfig.vendor_string, qglGetString (GL_VENDOR), sizeof( glConfig.vendor_string ) ); Q_strncpyz( glConfig.renderer_string, qglGetString (GL_RENDERER), sizeof( glConfig.renderer_string ) ); Q_strncpyz( glConfig.version_string, qglGetString (GL_VERSION), sizeof( glConfig.version_string ) ); Q_strncpyz( glConfig.extensions_string, qglGetString (GL_EXTENSIONS), sizeof( glConfig.extensions_string ) ); // // chipset specific configuration // Q_strncpyz( buf, glConfig.renderer_string, sizeof(buf) ); Q_strlwr( buf ); // // NOTE: if changing cvars, do it within this block. This allows them // to be overridden when testing driver fixes, etc. but only sets // them to their default state when the hardware is first installed/run. // if ( Q_stricmp( lastValidRenderer->string, glConfig.renderer_string ) ) { glConfig.hardwareType = GLHW_GENERIC; ri.Cvar_Set( "r_textureMode", "GL_LINEAR_MIPMAP_NEAREST" ); // VOODOO GRAPHICS w/ 2MB if ( strstr( buf, "voodoo graphics/1 tmu/2 mb" ) ) { ri.Cvar_Set( "r_picmip", "2" ); ri.Cvar_Get( "r_picmip", "1", CVAR_ARCHIVE | CVAR_LATCH ); } else { ri.Cvar_Set( "r_picmip", "1" ); if ( strstr( buf, "rage 128" ) || strstr( buf, "rage128" ) ) { ri.Cvar_Set( "r_finish", "0" ); } // Savage3D and Savage4 should always have trilinear enabled else if ( strstr( buf, "savage3d" ) || strstr( buf, "s3 savage4" ) ) { ri.Cvar_Set( "r_texturemode", "GL_LINEAR_MIPMAP_LINEAR" ); } } } // // this is where hardware specific workarounds that should be // detected/initialized every startup should go. // if ( strstr( buf, "banshee" ) || strstr( buf, "voodoo3" ) ) { glConfig.hardwareType = GLHW_3DFX_2D3D; } // VOODOO GRAPHICS w/ 2MB else if ( strstr( buf, "voodoo graphics/1 tmu/2 mb" ) ) { } else if ( strstr( buf, "glzicd" ) ) { } else if ( strstr( buf, "rage pro" ) || strstr( buf, "Rage Pro" ) || strstr( buf, "ragepro" ) ) { glConfig.hardwareType = GLHW_RAGEPRO; } else if ( strstr( buf, "rage 128" ) ) { } else if ( strstr( buf, "permedia2" ) ) { glConfig.hardwareType = GLHW_PERMEDIA2; } else if ( strstr( buf, "riva 128" ) ) { glConfig.hardwareType = GLHW_RIVA128; } else if ( strstr( buf, "riva tnt " ) ) { } ri.Cvar_Set( "r_lastValidRenderer", glConfig.renderer_string ); GLW_InitExtensions(); WG_CheckHardwareGamma(); }

Here is the call graph for this function:

void GLimp_LogComment (  char *  comment  )

Definition at line 1545 of file win_glimp.c. References fprintf(), glw_state, and glwstate_t::log_fp. Referenced by DrawTris(), GL_SelectTexture(), RB_EndSurface(), RB_StageIteratorGeneric(), RB_StageIteratorLightmappedMultitexture(), RB_StageIteratorVertexLitTexture(), RB_SwapBuffers(), and RE_RenderScene(). { if ( glw_state.log_fp ) { fprintf( glw_state.log_fp, "%s", comment ); } }

Here is the call graph for this function:

void* GLimp_RendererSleep (  void   )

Definition at line 1607 of file win_glimp.c. References data, GLSTAMP, glw_state, glwstate_t::hDC, glwstate_t::hGLRC, INFINITE, mainThreadCondition, NULL, OSX_GLContextClearCurrent, OSX_GLContextSetCurrent, renderActiveEvent, renderCommandsEvent, renderCompletedEvent, renderThreadCondition, smpData, smpDataChanged, smpMutex, and wglErrors. { void *data; if ( !qwglMakeCurrent( glw_state.hDC, NULL ) ) { wglErrors++; } ResetEvent( renderActiveEvent ); // after this, the front end can exit GLimp_FrontEndSleep SetEvent( renderCompletedEvent ); WaitForSingleObject( renderCommandsEvent, INFINITE ); if ( !qwglMakeCurrent( glw_state.hDC, glw_state.hGLRC ) ) { wglErrors++; } ResetEvent( renderCompletedEvent ); ResetEvent( renderCommandsEvent ); data = smpData; // after this, the main thread can exit GLimp_WakeRenderer SetEvent( renderActiveEvent ); return data; }

void GLimp_RenderThreadWrapper (  void   )

Definition at line 1567 of file win_glimp.c. References glimpRenderThread, glw_state, glwstate_t::hDC, and NULL. { glimpRenderThread(); // unbind the context before we die qwglMakeCurrent( glw_state.hDC, NULL ); }

void GLimp_Shutdown (  void   )

Definition at line 1470 of file win_glimp.c. References _GLimp_RestoreOriginalVideoSettings(), glwgamma_t::blue, glwstate_t::cdsFullscreen, Com_Printf(), glconfig_t::deviceSupportsGamma, glwstate_t::displayCount, fclose(), free(), g_wv, glConfig, glState, glw_state, glwgamma_t::green, glwstate_t::hDC, glwstate_t::hGLRC, WinVars_t::hWnd, glwstate_t::inGameTable, glwstate_t::log_fp, memset(), NULL, glwstate_t::originalDisplayGammaTables, OSX_GetCGLContext, OSX_GetNSGLContext, OSX_GLContextClearCurrent, OSX_SetGLContext, glwstate_t::pixelFormatSet, PRINT_ALL, QGL_Shutdown(), glwgamma_t::red, ri, Sys_DisplayToUse(), Sys_FadeScreen(), Sys_UnfadeScreens(), glwstate_t::tempTable, WG_RestoreGamma(), and glwstate_t::window. { // const char *strings[] = { "soft", "hard" }; const char *success[] = { "failed", "success" }; int retVal; // FIXME: Brian, we need better fallbacks from partially initialized failures if ( !qwglMakeCurrent ) { return; } ri.Printf( PRINT_ALL, "Shutting down OpenGL subsystem\n" ); // restore gamma. We do this first because 3Dfx's extension needs a valid OGL subsystem WG_RestoreGamma(); // set current context to NULL if ( qwglMakeCurrent ) { retVal = qwglMakeCurrent( NULL, NULL ) != 0; ri.Printf( PRINT_ALL, "...wglMakeCurrent( NULL, NULL ): %s\n", success[retVal] ); } // delete HGLRC if ( glw_state.hGLRC ) { retVal = qwglDeleteContext( glw_state.hGLRC ) != 0; ri.Printf( PRINT_ALL, "...deleting GL context: %s\n", success[retVal] ); glw_state.hGLRC = NULL; } // release DC if ( glw_state.hDC ) { retVal = ReleaseDC( g_wv.hWnd, glw_state.hDC ) != 0; ri.Printf( PRINT_ALL, "...releasing DC: %s\n", success[retVal] ); glw_state.hDC = NULL; } // destroy window if ( g_wv.hWnd ) { ri.Printf( PRINT_ALL, "...destroying window\n" ); ShowWindow( g_wv.hWnd, SW_HIDE ); DestroyWindow( g_wv.hWnd ); g_wv.hWnd = NULL; glw_state.pixelFormatSet = qfalse; } // close the r_logFile if ( glw_state.log_fp ) { fclose( glw_state.log_fp ); glw_state.log_fp = 0; } // reset display settings if ( glw_state.cdsFullscreen ) { ri.Printf( PRINT_ALL, "...resetting display\n" ); ChangeDisplaySettings( 0, 0 ); glw_state.cdsFullscreen = qfalse; } // shutdown QGL subsystem QGL_Shutdown(); memset( &glConfig, 0, sizeof( glConfig ) ); memset( &glState, 0, sizeof( glState ) ); }

Here is the call graph for this function:

qboolean GLimp_SpawnRenderThread (  void(*)(void)  function  )

Definition at line 1581 of file win_glimp.c. References FALSE, GLimp_RenderThreadWrapper(), glimpRenderThread, mainThreadCondition, NULL, PRINT_ALL, qboolean, renderActiveEvent, renderCommandsEvent, renderCompletedEvent, renderThreadCondition, renderThreadHandle, renderThreadId, ri, smpMutex, strerror(), and TRUE. Referenced by R_InitCommandBuffers(). { renderCommandsEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); renderCompletedEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); renderActiveEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); glimpRenderThread = function; renderThreadHandle = CreateThread( NULL, // LPSECURITY_ATTRIBUTES lpsa, 0, // DWORD cbStack, (LPTHREAD_START_ROUTINE)GLimp_RenderThreadWrapper, // LPTHREAD_START_ROUTINE lpStartAddr, 0, // LPVOID lpvThreadParm, 0, // DWORD fdwCreate, &renderThreadId ); if ( !renderThreadHandle ) { return qfalse; } return qtrue; }

Here is the call graph for this function:

void GLimp_WakeRenderer (  void *  data  )

Definition at line 1646 of file win_glimp.c. References assert, data, GLSTAMP, glw_state, glwstate_t::hDC, INFINITE, NULL, OSX_GLContextClearCurrent, renderActiveEvent, renderCommandsEvent, renderThreadCondition, smpData, smpDataChanged, smpMutex, and wglErrors. Referenced by R_IssueRenderCommands(), and R_ShutdownCommandBuffers(). { smpData = data; if ( !qwglMakeCurrent( glw_state.hDC, NULL ) ) { wglErrors++; } // after this, the renderer can continue through GLimp_RendererSleep SetEvent( renderCommandsEvent ); WaitForSingleObject( renderActiveEvent, INFINITE ); }

qboolean GLW_CheckOSVersion (  void   )  [static]

Definition at line 1121 of file win_glimp.c. References glwstate_t::allowdisplaydepthchange, glw_state, PRINT_ALL, qboolean, and ri. Referenced by GLimp_Init(). { #define OSR2_BUILD_NUMBER 1111 OSVERSIONINFO vinfo; vinfo.dwOSVersionInfoSize = sizeof(vinfo); glw_state.allowdisplaydepthchange = qfalse; if ( GetVersionEx( &vinfo) ) { if ( vinfo.dwMajorVersion > 4 ) { glw_state.allowdisplaydepthchange = qtrue; } else if ( vinfo.dwMajorVersion == 4 ) { if ( vinfo.dwPlatformId == VER_PLATFORM_WIN32_NT ) { glw_state.allowdisplaydepthchange = qtrue; } else if ( vinfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS ) { if ( LOWORD( vinfo.dwBuildNumber ) >= OSR2_BUILD_NUMBER ) { glw_state.allowdisplaydepthchange = qtrue; } } } } else { ri.Printf( PRINT_ALL, "GLW_CheckOSVersion() - GetVersionEx failed\n" ); return qfalse; } return qtrue; }

int GLW_ChoosePFD (  HDC  hDC, PIXELFORMATDESCRIPTOR *  pPFD )  [static]

Definition at line 120 of file win_glimp.c. References glconfig_t::driverType, glConfig, i, cvar_s::integer, MAX_PFDS, PRINT_ALL, PRINT_WARNING, r_allowSoftwareGL, r_verbose, and ri. Referenced by GLW_MakeContext(). { PIXELFORMATDESCRIPTOR pfds[MAX_PFDS+1]; int maxPFD = 0; int i; int bestMatch = 0; ri.Printf( PRINT_ALL, "...GLW_ChoosePFD( %d, %d, %d )\n", ( int ) pPFD->cColorBits, ( int ) pPFD->cDepthBits, ( int ) pPFD->cStencilBits ); // count number of PFDs if ( glConfig.driverType > GLDRV_ICD ) { maxPFD = qwglDescribePixelFormat( hDC, 1, sizeof( PIXELFORMATDESCRIPTOR ), &pfds[0] ); } else { maxPFD = DescribePixelFormat( hDC, 1, sizeof( PIXELFORMATDESCRIPTOR ), &pfds[0] ); } if ( maxPFD > MAX_PFDS ) { ri.Printf( PRINT_WARNING, "...numPFDs > MAX_PFDS (%d > %d)\n", maxPFD, MAX_PFDS ); maxPFD = MAX_PFDS; } ri.Printf( PRINT_ALL, "...%d PFDs found\n", maxPFD - 1 ); // grab information for ( i = 1; i <= maxPFD; i++ ) { if ( glConfig.driverType > GLDRV_ICD ) { qwglDescribePixelFormat( hDC, i, sizeof( PIXELFORMATDESCRIPTOR ), &pfds[i] ); } else { DescribePixelFormat( hDC, i, sizeof( PIXELFORMATDESCRIPTOR ), &pfds[i] ); } } // look for a best match for ( i = 1; i <= maxPFD; i++ ) { // // make sure this has hardware acceleration // if ( ( pfds[i].dwFlags & PFD_GENERIC_FORMAT ) != 0 ) { if ( !r_allowSoftwareGL->integer ) { if ( r_verbose->integer ) { ri.Printf( PRINT_ALL, "...PFD %d rejected, software acceleration\n", i ); } continue; } } // verify pixel type if ( pfds[i].iPixelType != PFD_TYPE_RGBA ) { if ( r_verbose->integer ) { ri.Printf( PRINT_ALL, "...PFD %d rejected, not RGBA\n", i ); } continue; } // verify proper flags if ( ( ( pfds[i].dwFlags & pPFD->dwFlags ) & pPFD->dwFlags ) != pPFD->dwFlags ) { if ( r_verbose->integer ) { ri.Printf( PRINT_ALL, "...PFD %d rejected, improper flags (%x instead of %x)\n", i, pfds[i].dwFlags, pPFD->dwFlags ); } continue; } // verify enough bits if ( pfds[i].cDepthBits < 15 ) { continue; } if ( ( pfds[i].cStencilBits < 4 ) && ( pPFD->cStencilBits > 0 ) ) { continue; } // // selection criteria (in order of priority): // // PFD_STEREO // colorBits // depthBits // stencilBits // if ( bestMatch ) { // check stereo if ( ( pfds[i].dwFlags & PFD_STEREO ) && ( !( pfds[bestMatch].dwFlags & PFD_STEREO ) ) && ( pPFD->dwFlags & PFD_STEREO ) ) { bestMatch = i; continue; } if ( !( pfds[i].dwFlags & PFD_STEREO ) && ( pfds[bestMatch].dwFlags & PFD_STEREO ) && ( pPFD->dwFlags & PFD_STEREO ) ) { bestMatch = i; continue; } // check color if ( pfds[bestMatch].cColorBits != pPFD->cColorBits ) { // prefer perfect match if ( pfds[i].cColorBits == pPFD->cColorBits ) { bestMatch = i; continue; } // otherwise if this PFD has more bits than our best, use it else if ( pfds[i].cColorBits > pfds[bestMatch].cColorBits ) { bestMatch = i; continue; } } // check depth if ( pfds[bestMatch].cDepthBits != pPFD->cDepthBits ) { // prefer perfect match if ( pfds[i].cDepthBits == pPFD->cDepthBits ) { bestMatch = i; continue; } // otherwise if this PFD has more bits than our best, use it else if ( pfds[i].cDepthBits > pfds[bestMatch].cDepthBits ) { bestMatch = i; continue; } } // check stencil if ( pfds[bestMatch].cStencilBits != pPFD->cStencilBits ) { // prefer perfect match if ( pfds[i].cStencilBits == pPFD->cStencilBits ) { bestMatch = i; continue; } // otherwise if this PFD has more bits than our best, use it else if ( ( pfds[i].cStencilBits > pfds[bestMatch].cStencilBits ) && ( pPFD->cStencilBits > 0 ) ) { bestMatch = i; continue; } } } else { bestMatch = i; } } if ( !bestMatch ) return 0; if ( ( pfds[bestMatch].dwFlags & PFD_GENERIC_FORMAT ) != 0 ) { if ( !r_allowSoftwareGL->integer ) { ri.Printf( PRINT_ALL, "...no hardware acceleration found\n" ); return 0; } else { ri.Printf( PRINT_ALL, "...using software emulation\n" ); } } else if ( pfds[bestMatch].dwFlags & PFD_GENERIC_ACCELERATED ) { ri.Printf( PRINT_ALL, "...MCD acceleration found\n" ); } else { ri.Printf( PRINT_ALL, "...hardware acceleration found\n" ); } *pPFD = pfds[bestMatch]; return bestMatch; }

void GLW_CreatePFD (  PIXELFORMATDESCRIPTOR *  pPFD, int  colorbits, int  depthbits, int  stencilbits, qboolean  stereo )  [static]

Definition at line 322 of file win_glimp.c. References glConfig, PRINT_ALL, ri, src, and glconfig_t::stereoEnabled. Referenced by GLW_InitDriver(). { 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 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, // 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 }; src.cColorBits = colorbits; src.cDepthBits = depthbits; src.cStencilBits = stencilbits; if ( stereo ) { ri.Printf( PRINT_ALL, "...attempting to use stereo\n" ); src.dwFlags |= PFD_STEREO; glConfig.stereoEnabled = qtrue; } else { glConfig.stereoEnabled = qfalse; } *pPFD = src; }

qboolean GLW_CreateWindow (  const char *  drivername, int  width, int  height, int  colorbits, qboolean  cdsFullscreen )  [static]

Definition at line 577 of file win_glimp.c. References _3DFX_DRIVER_NAME, refimport_t::Cvar_Get, cvar_t, glwstate_t::desktopHeight, glwstate_t::desktopWidth, ERR_FATAL, FALSE, g_wv, GLW_InitDriver(), glw_state, h(), WinVars_t::hInstance, glwstate_t::hInstance, WinVars_t::hWnd, IDI_ICON1, cvar_s::integer, memset(), NULL, PRINT_ALL, Q_stricmp(), qboolean, r, ri, s_classRegistered, vid_xpos, vid_ypos, w, WINDOW_CLASS_NAME, WINDOW_STYLE, glwstate_t::wndproc, x, and y. Referenced by GLW_SetMode(). { RECT r; cvar_t *vid_xpos, *vid_ypos; int stylebits; int x, y, w, h; int exstyle; // // register the window class if necessary // if ( !s_classRegistered ) { WNDCLASS wc; memset( &wc, 0, sizeof( wc ) ); wc.style = 0; wc.lpfnWndProc = (WNDPROC) glw_state.wndproc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = g_wv.hInstance; wc.hIcon = LoadIcon( g_wv.hInstance, MAKEINTRESOURCE(IDI_ICON1)); wc.hCursor = LoadCursor (NULL,IDC_ARROW); wc.hbrBackground = (void *)COLOR_GRAYTEXT; wc.lpszMenuName = 0; wc.lpszClassName = WINDOW_CLASS_NAME; if ( !RegisterClass( &wc ) ) { ri.Error( ERR_FATAL, "GLW_CreateWindow: could not register window class" ); } s_classRegistered = qtrue; ri.Printf( PRINT_ALL, "...registered window class\n" ); } // // create the HWND if one does not already exist // if ( !g_wv.hWnd ) { // // compute width and height // r.left = 0; r.top = 0; r.right = width; r.bottom = height; if ( cdsFullscreen || !Q_stricmp( _3DFX_DRIVER_NAME, drivername ) ) { exstyle = WS_EX_TOPMOST; stylebits = WS_POPUP|WS_VISIBLE|WS_SYSMENU; } else { exstyle = 0; stylebits = WINDOW_STYLE|WS_SYSMENU; AdjustWindowRect (&r, stylebits, FALSE); } w = r.right - r.left; h = r.bottom - r.top; if ( cdsFullscreen || !Q_stricmp( _3DFX_DRIVER_NAME, drivername ) ) { x = 0; y = 0; } else { vid_xpos = ri.Cvar_Get ("vid_xpos", "", 0); vid_ypos = ri.Cvar_Get ("vid_ypos", "", 0); x = vid_xpos->integer; y = vid_ypos->integer; // adjust window coordinates if necessary // so that the window is completely on screen if ( x < 0 ) x = 0; if ( y < 0 ) y = 0; if ( w < glw_state.desktopWidth && h < glw_state.desktopHeight ) { if ( x + w > glw_state.desktopWidth ) x = ( glw_state.desktopWidth - w ); if ( y + h > glw_state.desktopHeight ) y = ( glw_state.desktopHeight - h ); } } g_wv.hWnd = CreateWindowEx ( exstyle, WINDOW_CLASS_NAME, "Quake 3: Arena", stylebits, x, y, w, h, NULL, NULL, g_wv.hInstance, NULL); if ( !g_wv.hWnd ) { ri.Error (ERR_FATAL, "GLW_CreateWindow() - Couldn't create window"); } ShowWindow( g_wv.hWnd, SW_SHOW ); UpdateWindow( g_wv.hWnd ); ri.Printf( PRINT_ALL, "...created window@%d,%d (%dx%d)\n", x, y, w, h ); } else { ri.Printf( PRINT_ALL, "...window already present, CreateWindowEx skipped\n" ); } if ( !GLW_InitDriver( drivername, colorbits ) ) { ShowWindow( g_wv.hWnd, SW_HIDE ); DestroyWindow( g_wv.hWnd ); g_wv.hWnd = NULL; return qfalse; } SetForegroundWindow( g_wv.hWnd ); SetFocus( g_wv.hWnd ); return qtrue; }

Here is the call graph for this function:

qboolean GLW_InitDriver (  const char *  drivername, int  colorbits )  [static]

Definition at line 447 of file win_glimp.c. References glconfig_t::colorBits, glconfig_t::depthBits, glwstate_t::desktopBitsPixel, g_wv, glConfig, GLW_CreatePFD(), GLW_MakeContext(), glw_state, glwstate_t::hDC, WinVars_t::hWnd, cvar_s::integer, glwstate_t::pixelFormatSet, PRINT_ALL, PRINT_WARNING, qboolean, r_colorbits, r_depthbits, r_stencilbits, r_stereo, ri, glconfig_t::stencilBits, and glconfig_t::stereoEnabled. Referenced by GLW_CreateWindow(). { int tpfd; int depthbits, stencilbits; static PIXELFORMATDESCRIPTOR pfd; // save between frames since 'tr' gets cleared ri.Printf( PRINT_ALL, "Initializing OpenGL driver\n" ); // // get a DC for our window if we don't already have one allocated // if ( glw_state.hDC == NULL ) { ri.Printf( PRINT_ALL, "...getting DC: " ); if ( ( glw_state.hDC = GetDC( g_wv.hWnd ) ) == NULL ) { ri.Printf( PRINT_ALL, "failed\n" ); return qfalse; } ri.Printf( PRINT_ALL, "succeeded\n" ); } if ( colorbits == 0 ) { colorbits = glw_state.desktopBitsPixel; } // // implicitly assume Z-buffer depth == desktop color depth // if ( r_depthbits->integer == 0 ) { if ( colorbits > 16 ) { depthbits = 24; } else { depthbits = 16; } } else { depthbits = r_depthbits->integer; } // // do not allow stencil if Z-buffer depth likely won't contain it // stencilbits = r_stencilbits->integer; if ( depthbits < 24 ) { stencilbits = 0; } // // make two attempts to set the PIXELFORMAT // // // first attempt: r_colorbits, depthbits, and r_stencilbits // if ( !glw_state.pixelFormatSet ) { GLW_CreatePFD( &pfd, colorbits, depthbits, stencilbits, r_stereo->integer ); if ( ( tpfd = GLW_MakeContext( &pfd ) ) != TRY_PFD_SUCCESS ) { if ( tpfd == TRY_PFD_FAIL_HARD ) { ri.Printf( PRINT_WARNING, "...failed hard\n" ); return qfalse; } // // punt if we've already tried the desktop bit depth and no stencil bits // if ( ( r_colorbits->integer == glw_state.desktopBitsPixel ) && ( stencilbits == 0 ) ) { ReleaseDC( g_wv.hWnd, glw_state.hDC ); glw_state.hDC = NULL; ri.Printf( PRINT_ALL, "...failed to find an appropriate PIXELFORMAT\n" ); return qfalse; } // // second attempt: desktop's color bits and no stencil // if ( colorbits > glw_state.desktopBitsPixel ) { colorbits = glw_state.desktopBitsPixel; } GLW_CreatePFD( &pfd, colorbits, depthbits, 0, r_stereo->integer ); if ( GLW_MakeContext( &pfd ) != TRY_PFD_SUCCESS ) { if ( glw_state.hDC ) { ReleaseDC( g_wv.hWnd, glw_state.hDC ); glw_state.hDC = NULL; } ri.Printf( PRINT_ALL, "...failed to find an appropriate PIXELFORMAT\n" ); return qfalse; } } /* ** report if stereo is desired but unavailable */ if ( !( pfd.dwFlags & PFD_STEREO ) && ( r_stereo->integer != 0 ) ) { ri.Printf( PRINT_ALL, "...failed to select stereo pixel format\n" ); glConfig.stereoEnabled = qfalse; } } /* ** store PFD specifics */ glConfig.colorBits = ( int ) pfd.cColorBits; glConfig.depthBits = ( int ) pfd.cDepthBits; glConfig.stencilBits = ( int ) pfd.cStencilBits; return qtrue; }

Here is the call graph for this function: