![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to glw_imp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake II] / quake2 / win32|
Return to glw_imp.c CVS log | Up to [Quake II] / quake2 / win32 |
1.1 root 1: /*
2: ** GLW_IMP.C
3: **
4: ** This file contains ALL Win32 specific stuff having to do with the
5: ** OpenGL refresh. When a port is being made the following functions
6: ** must be implemented by the port:
7: **
8: ** GLimp_EndFrame
9: ** GLimp_Init
10: ** GLimp_Shutdown
11: ** GLimp_SwitchFullscreen
12: **
13: */
14: #include <assert.h>
15: #include <windows.h>
16: #include "../ref_gl/gl_local.h"
17: #include "glw_win.h"
18: #include "winquake.h"
19:
20: static qboolean GLimp_SwitchFullscreen( int width, int height );
21: qboolean GLimp_InitGL (void);
22:
23: glwstate_t glw_state;
24:
25: extern cvar_t *vid_fullscreen;
26: extern cvar_t *vid_ref;
27:
28: static qboolean VerifyDriver( void )
29: {
30: char buffer[1024];
31:
32: strcpy( buffer, qglGetString( GL_RENDERER ) );
33: strlwr( buffer );
34: if ( strcmp( buffer, "gdi generic" ) == 0 )
35: if ( !glw_state.mcd_accelerated )
36: return false;
37: return true;
38: }
39:
40: /*
41: ** VID_CreateWindow
42: */
43: #define WINDOW_CLASS_NAME "Quake 2"
44:
45: qboolean VID_CreateWindow( int width, int height, qboolean fullscreen )
46: {
47: WNDCLASS wc;
48: RECT r;
49: cvar_t *vid_xpos, *vid_ypos;
50: int stylebits;
51: int x, y, w, h;
52: int exstyle;
53:
54: /* Register the frame class */
55: wc.style = 0;
56: wc.lpfnWndProc = (WNDPROC)glw_state.wndproc;
57: wc.cbClsExtra = 0;
58: wc.cbWndExtra = 0;
59: wc.hInstance = glw_state.hInstance;
60: wc.hIcon = 0;
61: wc.hCursor = LoadCursor (NULL,IDC_ARROW);
62: wc.hbrBackground = (void *)COLOR_GRAYTEXT;
63: wc.lpszMenuName = 0;
64: wc.lpszClassName = WINDOW_CLASS_NAME;
65:
66: if (!RegisterClass (&wc) )
67: ri.Sys_Error (ERR_FATAL, "Couldn't register window class");
68:
69: if (fullscreen)
70: {
71: exstyle = WS_EX_TOPMOST;
72: stylebits = WS_POPUP|WS_VISIBLE;
73: }
74: else
75: {
76: exstyle = 0;
77: stylebits = WINDOW_STYLE;
78: }
79:
80: r.left = 0;
81: r.top = 0;
82: r.right = width;
83: r.bottom = height;
84:
85: AdjustWindowRect (&r, stylebits, FALSE);
86:
87: w = r.right - r.left;
88: h = r.bottom - r.top;
89:
90: if (fullscreen)
91: {
92: x = 0;
93: y = 0;
94: }
95: else
96: {
97: vid_xpos = ri.Cvar_Get ("vid_xpos", "0", 0);
98: vid_ypos = ri.Cvar_Get ("vid_ypos", "0", 0);
99: x = vid_xpos->value;
100: y = vid_ypos->value;
101: }
102:
103: glw_state.hWnd = CreateWindowEx (
104: exstyle,
105: WINDOW_CLASS_NAME,
106: "Quake 2",
107: stylebits,
108: x, y, w, h,
109: NULL,
110: NULL,
111: glw_state.hInstance,
112: NULL);
113:
114: if (!glw_state.hWnd)
115: ri.Sys_Error (ERR_FATAL, "Couldn't create window");
116:
117: ShowWindow( glw_state.hWnd, SW_SHOW );
118: UpdateWindow( glw_state.hWnd );
119:
120: // init all the gl stuff for the window
121: if (!GLimp_InitGL ())
122: {
123: ri.Con_Printf( PRINT_ALL, "VID_CreateWindow() - GLimp_InitGL failed\n");
124: return false;
125: }
126:
127: SetForegroundWindow( glw_state.hWnd );
128: SetFocus( glw_state.hWnd );
129:
130: // let the sound and input subsystems know about the new window
131: ri.Vid_NewWindow (width, height);
132:
133: return true;
134: }
135:
136:
137: /*
138: ** GLimp_SetMode
139: */
140: rserr_t GLimp_SetMode( int *pwidth, int *pheight, int mode, qboolean fullscreen )
141: {
142: int width, height;
143: const char *win_fs[] = { "W", "FS" };
144:
145: ri.Con_Printf( PRINT_ALL, "Initializing OpenGL display\n");
146:
147: ri.Con_Printf (PRINT_ALL, "...setting mode %d:", mode );
148:
149: if ( !ri.Vid_GetModeInfo( &width, &height, mode ) )
150: {
151: ri.Con_Printf( PRINT_ALL, " invalid mode\n" );
152: return rserr_invalid_mode;
153: }
154:
155: ri.Con_Printf( PRINT_ALL, " %d %d %s\n", width, height, win_fs[fullscreen] );
156:
157: // destroy the existing window
158: if (glw_state.hWnd)
159: {
160: GLimp_Shutdown ();
161: }
162:
163: // do a CDS if needed
164: if ( fullscreen )
165: {
166: DEVMODE dm;
167:
168: ri.Con_Printf( PRINT_ALL, "...attempting fullscreen\n" );
169:
170: memset( &dm, 0, sizeof( dm ) );
171:
172: dm.dmSize = sizeof( dm );
173:
174: dm.dmPelsWidth = width;
175: dm.dmPelsHeight = height;
176: dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
177:
178: if ( gl_bitdepth->value != 0 )
179: {
180: dm.dmBitsPerPel = gl_bitdepth->value;
181: dm.dmFields |= DM_BITSPERPEL;
182: ri.Con_Printf( PRINT_ALL, "...using gl_bitdepth of %d\n", ( int ) gl_bitdepth->value );
183: }
184: else
185: {
186: HDC hdc = GetDC( NULL );
187: int bitspixel = GetDeviceCaps( hdc, BITSPIXEL );
188:
189: ri.Con_Printf( PRINT_ALL, "...using desktop display depth of %d\n", bitspixel );
190:
191: ReleaseDC( 0, hdc );
192: }
193:
194: ri.Con_Printf( PRINT_ALL, "...calling CDS: " );
195: if ( ChangeDisplaySettings( &dm, CDS_FULLSCREEN ) == DISP_CHANGE_SUCCESSFUL )
196: {
197: *pwidth = width;
198: *pheight = height;
199:
200: gl_state.fullscreen = true;
201:
202: ri.Con_Printf( PRINT_ALL, "ok\n" );
203:
204: if ( !VID_CreateWindow (width, height, true) )
205: return rserr_invalid_mode;
206:
207: return rserr_ok;
208: }
209: else
210: {
211: *pwidth = width;
212: *pheight = height;
213:
214: ri.Con_Printf( PRINT_ALL, "failed\n" );
215:
216: ri.Con_Printf( PRINT_ALL, "...calling CDS assuming dual monitors:" );
217:
218: dm.dmPelsWidth = width * 2;
219: dm.dmPelsHeight = height;
220: dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
221:
222: if ( gl_bitdepth->value != 0 )
223: {
224: dm.dmBitsPerPel = gl_bitdepth->value;
225: dm.dmFields |= DM_BITSPERPEL;
226: }
227:
228: /*
229: ** our first CDS failed, so maybe we're running on some weird dual monitor
230: ** system
231: */
232: if ( ChangeDisplaySettings( &dm, CDS_FULLSCREEN ) != DISP_CHANGE_SUCCESSFUL )
233: {
234: ri.Con_Printf( PRINT_ALL, " failed\n" );
235:
236: ri.Con_Printf( PRINT_ALL, "...setting windowed mode\n" );
237:
238: ChangeDisplaySettings( 0, 0 );
239:
240: *pwidth = width;
241: *pheight = height;
242: gl_state.fullscreen = false;
243: if ( !VID_CreateWindow (width, height, false) )
244: return rserr_invalid_mode;
245: return rserr_invalid_fullscreen;
246: }
247: else
248: {
249: ri.Con_Printf( PRINT_ALL, " ok\n" );
250: if ( !VID_CreateWindow (width, height, true) )
251: return rserr_invalid_mode;
252:
253: gl_state.fullscreen = true;
254: return rserr_ok;
255: }
256: }
257: }
258: else
259: {
260: ri.Con_Printf( PRINT_ALL, "...setting windowed mode\n" );
261:
262: ChangeDisplaySettings( 0, 0 );
263:
264: *pwidth = width;
265: *pheight = height;
266: gl_state.fullscreen = false;
267: if ( !VID_CreateWindow (width, height, false) )
268: return rserr_invalid_mode;
269: }
270:
271: return rserr_ok;
272: }
273:
274: /*
275: ** GLimp_Shutdown
276: **
277: ** This routine does all OS specific shutdown procedures for the OpenGL
278: ** subsystem. Under OpenGL this means NULLing out the current DC and
279: ** HGLRC, deleting the rendering context, and releasing the DC acquired
280: ** for the window. The state structure is also nulled out.
281: **
282: */
283: void GLimp_Shutdown( void )
284: {
285: if ( qwglMakeCurrent && !qwglMakeCurrent( NULL, NULL ) )
286: ri.Con_Printf( PRINT_ALL, "ref_gl::R_Shutdown() - wglMakeCurrent failed\n");
287: if ( glw_state.hGLRC )
288: {
289: if ( qwglDeleteContext && !qwglDeleteContext( glw_state.hGLRC ) )
290: ri.Con_Printf( PRINT_ALL, "ref_gl::R_Shutdown() - wglDeleteContext failed\n");
291: glw_state.hGLRC = NULL;
292: }
293: if (glw_state.hDC)
294: {
295: if ( !ReleaseDC( glw_state.hWnd, glw_state.hDC ) )
296: ri.Con_Printf( PRINT_ALL, "ref_gl::R_Shutdown() - ReleaseDC failed\n" );
297: glw_state.hDC = NULL;
298: }
299: if (glw_state.hWnd)
300: {
301: DestroyWindow ( glw_state.hWnd );
302: glw_state.hWnd = NULL;
303: }
304:
305: if ( glw_state.log_fp )
306: {
307: fclose( glw_state.log_fp );
308: glw_state.log_fp = 0;
309: }
310:
311: UnregisterClass (WINDOW_CLASS_NAME, glw_state.hInstance);
312:
313: if ( gl_state.fullscreen )
314: {
315: ChangeDisplaySettings( 0, 0 );
316: gl_state.fullscreen = false;
317: }
318: }
319:
320:
321: /*
322: ** GLimp_Init
323: **
324: ** This routine is responsible for initializing the OS specific portions
325: ** of OpenGL. Under Win32 this means dealing with the pixelformats and
326: ** doing the wgl interface stuff.
327: */
328: qboolean GLimp_Init( void *hinstance, void *wndproc )
329: {
330: #define OSR2_BUILD_NUMBER 1111
331:
332: OSVERSIONINFO vinfo;
333:
334: vinfo.dwOSVersionInfoSize = sizeof(vinfo);
335:
336: glw_state.allowdisplaydepthchange = false;
337:
338: if ( GetVersionEx( &vinfo) )
339: {
340: if ( vinfo.dwMajorVersion > 4 )
341: {
342: glw_state.allowdisplaydepthchange = true;
343: }
344: else if ( vinfo.dwMajorVersion == 4 )
345: {
346: if ( vinfo.dwPlatformId == VER_PLATFORM_WIN32_NT )
347: {
348: glw_state.allowdisplaydepthchange = true;
349: }
350: else if ( vinfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
351: {
352: if ( LOWORD( vinfo.dwBuildNumber ) >= OSR2_BUILD_NUMBER )
353: {
354: glw_state.allowdisplaydepthchange = true;
355: }
356: }
357: }
358: }
359: else
360: {
361: ri.Con_Printf( PRINT_ALL, "GLimp_Init() - GetVersionEx failed\n" );
362: return false;
363: }
364:
365: glw_state.hInstance = ( HINSTANCE ) hinstance;
366: glw_state.wndproc = wndproc;
367:
368: return true;
369: }
370:
371: qboolean GLimp_InitGL (void)
372: {
373: PIXELFORMATDESCRIPTOR pfd =
374: {
375: sizeof(PIXELFORMATDESCRIPTOR), // size of this pfd
376: 1, // version number
377: PFD_DRAW_TO_WINDOW | // support window
378: PFD_SUPPORT_OPENGL | // support OpenGL
379: PFD_DOUBLEBUFFER, // double buffered
380: PFD_TYPE_RGBA, // RGBA type
381: 24, // 24-bit color depth
382: 0, 0, 0, 0, 0, 0, // color bits ignored
383: 0, // no alpha buffer
384: 0, // shift bit ignored
385: 0, // no accumulation buffer
386: 0, 0, 0, 0, // accum bits ignored
387: 32, // 32-bit z-buffer
388: 0, // no stencil buffer
389: 0, // no auxiliary buffer
390: PFD_MAIN_PLANE, // main layer
391: 0, // reserved
392: 0, 0, 0 // layer masks ignored
393: };
394: int pixelformat;
395: cvar_t *stereo;
396:
397: stereo = ri.Cvar_Get( "cl_stereo", "0", 0 );
398:
399: /*
400: ** set PFD_STEREO if necessary
401: */
402: if ( stereo->value != 0 )
403: {
404: ri.Con_Printf( PRINT_ALL, "...attempting to use stereo\n" );
405: pfd.dwFlags |= PFD_STEREO;
406: gl_state.stereo_enabled = true;
407: }
408: else
409: {
410: gl_state.stereo_enabled = false;
411: }
412:
413: /*
414: ** figure out if we're running on a minidriver or not
415: */
416: if ( strstr( gl_driver->string, "opengl32" ) != 0 )
417: glw_state.minidriver = false;
418: else
419: glw_state.minidriver = true;
420:
421: /*
422: ** Get a DC for the specified window
423: */
424: if ( glw_state.hDC != NULL )
425: ri.Con_Printf( PRINT_ALL, "GLimp_Init() - non-NULL DC exists\n" );
426:
427: if ( ( glw_state.hDC = GetDC( glw_state.hWnd ) ) == NULL )
428: {
429: ri.Con_Printf( PRINT_ALL, "GLimp_Init() - GetDC failed\n" );
430: return false;
431: }
432:
433: if ( glw_state.minidriver )
434: {
435: if ( (pixelformat = qwglChoosePixelFormat( glw_state.hDC, &pfd)) == 0 )
436: {
437: ri.Con_Printf (PRINT_ALL, "GLimp_Init() - qwglChoosePixelFormat failed\n");
438: return false;
439: }
440: if ( qwglSetPixelFormat( glw_state.hDC, pixelformat, &pfd) == FALSE )
441: {
442: ri.Con_Printf (PRINT_ALL, "GLimp_Init() - qwglSetPixelFormat failed\n");
443: return false;
444: }
445: qwglDescribePixelFormat( glw_state.hDC, pixelformat, sizeof( pfd ), &pfd );
446: }
447: else
448: {
449: if ( ( pixelformat = ChoosePixelFormat( glw_state.hDC, &pfd)) == 0 )
450: {
451: ri.Con_Printf (PRINT_ALL, "GLimp_Init() - ChoosePixelFormat failed\n");
452: return false;
453: }
454: if ( SetPixelFormat( glw_state.hDC, pixelformat, &pfd) == FALSE )
455: {
456: ri.Con_Printf (PRINT_ALL, "GLimp_Init() - SetPixelFormat failed\n");
457: return false;
458: }
459: DescribePixelFormat( glw_state.hDC, pixelformat, sizeof( pfd ), &pfd );
460:
461: if ( !( pfd.dwFlags & PFD_GENERIC_ACCELERATED ) )
462: {
463: extern cvar_t *gl_allow_software;
464:
465: if ( gl_allow_software->value )
466: glw_state.mcd_accelerated = true;
467: else
468: glw_state.mcd_accelerated = false;
469: }
470: else
471: {
472: glw_state.mcd_accelerated = true;
473: }
474: }
475:
476: /*
477: ** report if stereo is desired but unavailable
478: */
479: if ( !( pfd.dwFlags & PFD_STEREO ) && ( stereo->value != 0 ) )
480: {
481: ri.Con_Printf( PRINT_ALL, "...failed to select stereo pixel format\n" );
482: ri.Cvar_SetValue( "cl_stereo", 0 );
483: gl_state.stereo_enabled = false;
484: }
485:
486: /*
487: ** startup the OpenGL subsystem by creating a context and making
488: ** it current
489: */
490: if ( ( glw_state.hGLRC = qwglCreateContext( glw_state.hDC ) ) == 0 )
491: {
492: ri.Con_Printf (PRINT_ALL, "GLimp_Init() - qwglCreateContext failed\n");
493:
494: goto fail;
495: }
496:
497: if ( !qwglMakeCurrent( glw_state.hDC, glw_state.hGLRC ) )
498: {
499: ri.Con_Printf (PRINT_ALL, "GLimp_Init() - qwglMakeCurrent failed\n");
500:
501: goto fail;
502: }
503:
504: if ( !VerifyDriver() )
505: {
506: ri.Con_Printf( PRINT_ALL, "GLimp_Init() - no hardware acceleration detected\n" );
507: goto fail;
508: }
509:
510: /*
511: ** print out PFD specifics
512: */
513: ri.Con_Printf( PRINT_ALL, "GL PFD: color(%d-bits) Z(%d-bit)\n", ( int ) pfd.cColorBits, ( int ) pfd.cDepthBits );
514:
515: return true;
516:
517: fail:
518: if ( glw_state.hGLRC )
519: {
520: qwglDeleteContext( glw_state.hGLRC );
521: glw_state.hGLRC = NULL;
522: }
523:
524: if ( glw_state.hDC )
525: {
526: ReleaseDC( glw_state.hWnd, glw_state.hDC );
527: glw_state.hDC = NULL;
528: }
529: return false;
530: }
531:
532: /*
533: ** GLimp_BeginFrame
534: */
535: void GLimp_BeginFrame( float camera_separation )
536: {
537: if ( gl_bitdepth->modified )
538: {
539: if ( gl_bitdepth->value != 0 && !glw_state.allowdisplaydepthchange )
540: {
541: ri.Cvar_SetValue( "gl_bitdepth", 0 );
542: ri.Con_Printf( PRINT_ALL, "gl_bitdepth requires Win95 OSR2.x or WinNT 4.x\n" );
543: }
544: gl_bitdepth->modified = false;
545: }
546:
547: if ( camera_separation < 0 && gl_state.stereo_enabled )
548: {
549: qglDrawBuffer( GL_BACK_LEFT );
550: }
551: else if ( camera_separation > 0 && gl_state.stereo_enabled )
552: {
553: qglDrawBuffer( GL_BACK_RIGHT );
554: }
555: else
556: {
557: qglDrawBuffer( GL_BACK );
558: }
559: }
560:
561: /*
562: ** GLimp_EndFrame
563: **
564: ** Responsible for doing a swapbuffers and possibly for other stuff
565: ** as yet to be determined. Probably better not to make this a GLimp
566: ** function and instead do a call to GLimp_SwapBuffers.
567: */
568: void GLimp_EndFrame (void)
569: {
570: int err;
571:
572: err = qglGetError();
573: assert( err == GL_NO_ERROR );
574:
575: if ( stricmp( gl_drawbuffer->string, "GL_BACK" ) == 0 )
576: {
577: if ( !qwglSwapBuffers( glw_state.hDC ) )
578: ri.Sys_Error( ERR_FATAL, "GLimp_EndFrame() - SwapBuffers() failed!\n" );
579: }
580: }
581:
582: /*
583: ** GLimp_AppActivate
584: */
585: void GLimp_AppActivate( qboolean active )
586: {
587: if ( active )
588: {
589: SetForegroundWindow( glw_state.hWnd );
590: ShowWindow( glw_state.hWnd, SW_RESTORE );
591: }
592: else
593: {
594: if ( vid_fullscreen->value )
595: ShowWindow( glw_state.hWnd, SW_MINIMIZE );
596: }
597: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.