![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gl_vidnt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake] / quake1|
Return to gl_vidnt.c CVS log | Up to [Quake] / quake1 |
1.1 root 1: // gl_vidnt.c -- NT GL vid component
2:
3: #include "quakedef.h"
4: #include "winquake.h"
5: #include "resource.h"
6:
7: #define MAX_MODE_LIST 30
8: #define VID_ROW_SIZE 3
9: #define WARP_WIDTH 320
10: #define WARP_HEIGHT 200
11: #define MAXWIDTH 10000
12: #define MAXHEIGHT 10000
13: #define BASEWIDTH 320
14: #define BASEHEIGHT 200
15:
16: #define MODE_WINDOWED 0
17: #define NO_MODE (MODE_WINDOWED - 1)
18: #define MODE_FULLSCREEN_DEFAULT (MODE_WINDOWED + 1)
19:
20: typedef struct {
21: modestate_t type;
22: int width;
23: int height;
24: int modenum;
25: int dib;
26: int fullscreen;
27: int bpp;
28: int halfscreen;
29: char modedesc[17];
30: } vmode_t;
31:
32: typedef struct {
33: int width;
34: int height;
35: } lmode_t;
36:
37: lmode_t lowresmodes[] = {
38: {320, 200},
39: {320, 240},
40: {400, 300},
41: {512, 384},
42: };
43:
44: const char *gl_vendor;
45: const char *gl_renderer;
46: const char *gl_version;
47: const char *gl_extensions;
48:
49: qboolean DDActive;
50: qboolean scr_skipupdate;
51:
52: static vmode_t modelist[MAX_MODE_LIST];
53: static int nummodes;
54: static vmode_t *pcurrentmode;
55: static vmode_t badmode;
56:
57: static DEVMODE gdevmode;
58: static qboolean vid_initialized = false;
59: static qboolean windowed, leavecurrentmode;
60: static int windowed_mouse;
61: static HICON hIcon;
62:
63: int DIBWidth, DIBHeight;
64: RECT WindowRect;
65: DWORD WindowStyle, ExWindowStyle;
66:
67: HWND mainwindow, dibwindow;
68:
69: int vid_modenum = NO_MODE;
70: int vid_realmode;
71: int vid_default = MODE_WINDOWED;
72: static int windowed_default;
73:
74: unsigned char vid_curpal[256*3];
75:
76: HGLRC baseRC;
77: HDC maindc;
78:
79: glvert_t glv;
80:
81: cvar_t gl_ztrick = {"gl_ztrick","1"};
82:
83: HWND WINAPI InitializeWindow (HINSTANCE hInstance, int nCmdShow);
84:
85: viddef_t vid; // global video state
86:
87: unsigned short d_8to16table[256];
88: unsigned d_8to24table[256];
89:
90: float gldepthmin, gldepthmax;
91:
92: modestate_t modestate = MS_UNINIT;
93:
94: void VID_MenuDraw (void);
95: void VID_MenuKey (int key);
96:
97: LONG WINAPI MainWndProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
98: void AppActivate(BOOL fActive, BOOL minimize);
99: char *VID_GetModeDescription (int mode);
100: void ClearAllStates (void);
101: void VID_UpdateWindowStatus (void);
102: void GL_Init (void);
103:
104: PROC glArrayElementEXT;
105: PROC glColorPointerEXT;
106: PROC glTexCoordPointerEXT;
107: PROC glVertexPointerEXT;
108:
109: //====================================
110:
111: cvar_t vid_mode = {"vid_mode","0", false};
112: // Note that 0 is MODE_WINDOWED
113: cvar_t _vid_default_mode = {"_vid_default_mode","0", true};
114: // Note that 3 is MODE_FULLSCREEN_DEFAULT
115: cvar_t _vid_default_mode_win = {"_vid_default_mode_win","3", true};
116: cvar_t vid_wait = {"vid_wait","0"};
117: cvar_t vid_nopageflip = {"vid_nopageflip","0", true};
118: cvar_t _vid_wait_override = {"_vid_wait_override", "0", true};
119: cvar_t vid_config_x = {"vid_config_x","800", true};
120: cvar_t vid_config_y = {"vid_config_y","600", true};
121: cvar_t vid_stretch_by_2 = {"vid_stretch_by_2","1", true};
122: cvar_t _windowed_mouse = {"_windowed_mouse","0", true};
123:
124: int window_center_x, window_center_y, window_x, window_y, window_width, window_height;
125: RECT window_rect;
126:
127: // direct draw software compatability stuff
128:
129: void VID_HandlePause (qboolean pause)
130: {
131: }
132:
133: void VID_ForceLockState (int lk)
134: {
135: }
136:
137: void VID_LockBuffer (void)
138: {
139: }
140:
141: void VID_UnlockBuffer (void)
142: {
143: }
144:
145: int VID_ForceUnlockedAndReturnState (void)
146: {
147: return 0;
148: }
149:
150: void D_BeginDirectRect (int x, int y, byte *pbitmap, int width, int height)
151: {
152: }
153:
154: void D_EndDirectRect (int x, int y, int width, int height)
155: {
156: }
157:
158:
159: void CenterWindow(HWND hWndCenter, int width, int height, BOOL lefttopjustify)
160: {
161: RECT rect;
162: int CenterX, CenterY;
163:
164: CenterX = (GetSystemMetrics(SM_CXSCREEN) - width) / 2;
165: CenterY = (GetSystemMetrics(SM_CYSCREEN) - height) / 2;
166: if (CenterX > CenterY*2)
167: CenterX >>= 1; // dual screens
168: CenterX = (CenterX < 0) ? 0: CenterX;
169: CenterY = (CenterY < 0) ? 0: CenterY;
170: SetWindowPos (hWndCenter, NULL, CenterX, CenterY, 0, 0,
171: SWP_NOSIZE | SWP_NOZORDER | SWP_SHOWWINDOW | SWP_DRAWFRAME);
172: }
173:
174: qboolean VID_SetWindowedMode (int modenum)
175: {
176: HDC hdc;
177: int lastmodestate, width, height;
178: RECT rect;
179:
180: lastmodestate = modestate;
181:
182: WindowRect.top = WindowRect.left = 0;
183:
184: WindowRect.right = modelist[modenum].width;
185: WindowRect.bottom = modelist[modenum].height;
186:
187: DIBWidth = modelist[modenum].width;
188: DIBHeight = modelist[modenum].height;
189:
190: WindowStyle = WS_OVERLAPPED | WS_BORDER | WS_CAPTION | WS_SYSMENU |
191: WS_MINIMIZEBOX;
192: ExWindowStyle = 0;
193:
194: rect = WindowRect;
195: AdjustWindowRectEx(&rect, WindowStyle, FALSE, 0);
196:
197: width = rect.right - rect.left;
198: height = rect.bottom - rect.top;
199:
200: // Create the DIB window
201: dibwindow = CreateWindowEx (
202: ExWindowStyle,
203: "WinQuake",
204: "GLQuake",
205: WindowStyle,
206: rect.left, rect.top,
207: width,
208: height,
209: NULL,
210: NULL,
211: global_hInstance,
212: NULL);
213:
214: if (!dibwindow)
215: Sys_Error ("Couldn't create DIB window");
216:
217: // Center and show the DIB window
218: CenterWindow(dibwindow, WindowRect.right - WindowRect.left,
219: WindowRect.bottom - WindowRect.top, false);
220:
221: ShowWindow (dibwindow, SW_SHOWDEFAULT);
222: UpdateWindow (dibwindow);
223:
224: modestate = MS_WINDOWED;
225:
226: // because we have set the background brush for the window to NULL
227: // (to avoid flickering when re-sizing the window on the desktop),
228: // we clear the window to black when created, otherwise it will be
229: // empty while Quake starts up.
230: hdc = GetDC(dibwindow);
231: PatBlt(hdc,0,0,WindowRect.right,WindowRect.bottom,BLACKNESS);
232: ReleaseDC(dibwindow, hdc);
233:
234: vid.height = vid.conheight = BASEHEIGHT;
235: vid.width = vid.conwidth = BASEWIDTH;
236: vid.numpages = 2;
237:
238: mainwindow = dibwindow;
239:
240: SendMessage (mainwindow, WM_SETICON, (WPARAM)TRUE, (LPARAM)hIcon);
241: SendMessage (mainwindow, WM_SETICON, (WPARAM)FALSE, (LPARAM)hIcon);
242:
243: return true;
244: }
245:
246:
247: qboolean VID_SetFullDIBMode (int modenum)
248: {
249: HDC hdc;
250: int lastmodestate, width, height;
251: RECT rect;
252:
253: if (!leavecurrentmode)
254: {
255: gdevmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
256: gdevmode.dmBitsPerPel = modelist[modenum].bpp;
257: gdevmode.dmPelsWidth = modelist[modenum].width <<
258: modelist[modenum].halfscreen;
259: gdevmode.dmPelsHeight = modelist[modenum].height;
260: gdevmode.dmSize = sizeof (gdevmode);
261:
262: if (ChangeDisplaySettings (&gdevmode, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
263: Sys_Error ("Couldn't set fullscreen DIB mode");
264: }
265:
266: lastmodestate = modestate;
267: modestate = MS_FULLDIB;
268:
269: WindowRect.top = WindowRect.left = 0;
270:
271: WindowRect.right = modelist[modenum].width;
272: WindowRect.bottom = modelist[modenum].height;
273:
274: DIBWidth = modelist[modenum].width;
275: DIBHeight = modelist[modenum].height;
276:
277: WindowStyle = WS_POPUP;
278: ExWindowStyle = 0;
279:
280: rect = WindowRect;
281: AdjustWindowRectEx(&rect, WindowStyle, FALSE, 0);
282:
283: width = rect.right - rect.left;
284: height = rect.bottom - rect.top;
285:
286: // Create the DIB window
287: dibwindow = CreateWindowEx (
288: ExWindowStyle,
289: "WinQuake",
290: "GLQuake",
291: WindowStyle,
292: rect.left, rect.top,
293: width,
294: height,
295: NULL,
296: NULL,
297: global_hInstance,
298: NULL);
299:
300: if (!dibwindow)
301: Sys_Error ("Couldn't create DIB window");
302:
303: ShowWindow (dibwindow, SW_SHOWDEFAULT);
304: UpdateWindow (dibwindow);
305:
306: // Because we have set the background brush for the window to NULL
307: // (to avoid flickering when re-sizing the window on the desktop), we
308: // clear the window to black when created, otherwise it will be
309: // empty while Quake starts up.
310: hdc = GetDC(dibwindow);
311: PatBlt(hdc,0,0,WindowRect.right,WindowRect.bottom,BLACKNESS);
312: ReleaseDC(dibwindow, hdc);
313:
314: vid.height = vid.conheight = BASEHEIGHT;
315: vid.width = vid.conwidth = BASEWIDTH;
316: vid.numpages = 2;
317:
318: // needed because we're not getting WM_MOVE messages fullscreen on NT
319: window_x = 0;
320: window_y = 0;
321:
322: mainwindow = dibwindow;
323:
324: SendMessage (mainwindow, WM_SETICON, (WPARAM)TRUE, (LPARAM)hIcon);
325: SendMessage (mainwindow, WM_SETICON, (WPARAM)FALSE, (LPARAM)hIcon);
326:
327: return true;
328: }
329:
330:
331: int VID_SetMode (int modenum, unsigned char *palette)
332: {
333: int original_mode, temp;
334: qboolean stat;
335: MSG msg;
336: HDC hdc;
337:
338: if ((windowed && (modenum != 0)) ||
339: (!windowed && (modenum < 1)) ||
340: (!windowed && (modenum >= nummodes)))
341: {
342: Sys_Error ("Bad video mode\n");
343: }
344:
345: // so Con_Printfs don't mess us up by forcing vid and snd updates
346: temp = scr_disabled_for_loading;
347: scr_disabled_for_loading = true;
348:
349: Snd_ReleaseBuffer ();
350: CDAudio_Pause ();
351:
352: if (vid_modenum == NO_MODE)
353: original_mode = windowed_default;
354: else
355: original_mode = vid_modenum;
356:
357: // Set either the fullscreen or windowed mode
358: if (modelist[modenum].type == MS_WINDOWED)
359: {
360: if (_windowed_mouse.value)
361: {
362: stat = VID_SetWindowedMode(modenum);
363: IN_ActivateMouse ();
364: IN_HideMouse ();
365: }
366: else
367: {
368: IN_DeactivateMouse ();
369: IN_ShowMouse ();
370: stat = VID_SetWindowedMode(modenum);
371: }
372: }
373: else if (modelist[modenum].type == MS_FULLDIB)
374: {
375: stat = VID_SetFullDIBMode(modenum);
376: IN_ActivateMouse ();
377: IN_HideMouse ();
378: }
379: else
380: {
381: Sys_Error ("VID_SetMode: Bad mode type in modelist");
382: }
383:
384: window_width = DIBWidth;
385: window_height = DIBHeight;
386: VID_UpdateWindowStatus ();
387:
388: CDAudio_Resume ();
389: Snd_AcquireBuffer ();
390: scr_disabled_for_loading = temp;
391:
392: if (!stat)
393: {
394: Sys_Error ("Couldn't set video mode");
395: }
396:
397: // now we try to make sure we get the focus on the mode switch, because
398: // sometimes in some systems we don't. We grab the foreground, then
399: // finish setting up, pump all our messages, and sleep for a little while
400: // to let messages finish bouncing around the system, then we put
401: // ourselves at the top of the z order, then grab the foreground again,
402: // Who knows if it helps, but it probably doesn't hurt
403: SetForegroundWindow (mainwindow);
404: VID_SetPalette (palette);
405: vid_modenum = modenum;
406: Cvar_SetValue ("vid_mode", (float)vid_modenum);
407:
408: while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
409: {
410: TranslateMessage (&msg);
411: DispatchMessage (&msg);
412: }
413:
414: Sleep (100);
415:
416: SetWindowPos (mainwindow, HWND_TOP, 0, 0, 0, 0,
417: SWP_DRAWFRAME | SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW |
418: SWP_NOCOPYBITS);
419:
420: SetForegroundWindow (mainwindow);
421:
422: // fix the leftover Alt from any Alt-Tab or the like that switched us away
423: ClearAllStates ();
424:
425: if (!msg_suppress_1)
426: Con_SafePrintf ("%s\n", VID_GetModeDescription (vid_modenum));
427:
428: VID_SetPalette (palette);
429:
430: vid.recalc_refdef = 1;
431:
432: return true;
433: }
434:
435:
436: /*
437: ================
438: VID_UpdateWindowStatus
439: ================
440: */
441: void VID_UpdateWindowStatus (void)
442: {
443:
444: window_rect.left = window_x;
445: window_rect.top = window_y;
446: window_rect.right = window_x + window_width;
447: window_rect.bottom = window_y + window_height;
448: window_center_x = (window_rect.left + window_rect.right) / 2;
449: window_center_y = (window_rect.top + window_rect.bottom) / 2;
450:
451: IN_UpdateClipCursor ();
452: }
453:
454:
455: //====================================
456:
457: BINDTEXFUNCPTR bindTexFunc;
458:
459: #define TEXTURE_EXT_STRING "GL_EXT_texture_object"
460:
461:
462: void CheckTextureExtensions (void)
463: {
464: char *tmp;
465: qboolean texture_ext;
466: HINSTANCE hInstGL;
467:
468: texture_ext = FALSE;
469: /* check for texture extension */
470: tmp = (unsigned char *)glGetString(GL_EXTENSIONS);
471: while (*tmp)
472: {
473: if (strncmp((const char*)tmp, TEXTURE_EXT_STRING, strlen(TEXTURE_EXT_STRING)) == 0)
474: texture_ext = TRUE;
475: tmp++;
476: }
477:
478: if (!texture_ext || COM_CheckParm ("-gl11") )
479: {
480: hInstGL = LoadLibrary("opengl32.dll");
481:
482: if (hInstGL == NULL)
483: Sys_Error ("Couldn't load opengl32.dll\n");
484:
485: bindTexFunc = (void *)GetProcAddress(hInstGL,"glBindTexture");
486:
487: if (!bindTexFunc)
488: Sys_Error ("No texture objects!");
489: return;
490: }
491:
492: /* load library and get procedure adresses for texture extension API */
493: if ((bindTexFunc = (BINDTEXFUNCPTR)
494: wglGetProcAddress((LPCSTR) "glBindTextureEXT")) == NULL)
495: {
496: Sys_Error ("GetProcAddress for BindTextureEXT failed");
497: return;
498: }
499: }
500:
501: void CheckArrayExtensions (void)
502: {
503: char *tmp;
504:
505: /* check for texture extension */
506: tmp = (unsigned char *)glGetString(GL_EXTENSIONS);
507: while (*tmp)
508: {
509: if (strncmp((const char*)tmp, "GL_EXT_vertex_array", strlen("GL_EXT_vertex_array")) == 0)
510: {
511: if (
512: ((glArrayElementEXT = wglGetProcAddress("glArrayElementEXT")) == NULL) ||
513: ((glColorPointerEXT = wglGetProcAddress("glColorPointerEXT")) == NULL) ||
514: ((glTexCoordPointerEXT = wglGetProcAddress("glTexCoordPointerEXT")) == NULL) ||
515: ((glVertexPointerEXT = wglGetProcAddress("glVertexPointerEXT")) == NULL) )
516: {
517: Sys_Error ("GetProcAddress for vertex extension failed");
518: return;
519: }
520: return;
521: }
522: tmp++;
523: }
524:
525: Sys_Error ("Vertex array extension not present");
526: }
527:
528: //int texture_mode = GL_NEAREST;
529: //int texture_mode = GL_NEAREST_MIPMAP_NEAREST;
530: //int texture_mode = GL_NEAREST_MIPMAP_LINEAR;
531: int texture_mode = GL_LINEAR;
532: //int texture_mode = GL_LINEAR_MIPMAP_NEAREST;
533: //int texture_mode = GL_LINEAR_MIPMAP_LINEAR;
534:
535: int texture_extension_number = 1;
536:
537: /*
538: ===============
539: GL_Init
540: ===============
541: */
542: void GL_Init (void)
543: {
544: gl_vendor = glGetString (GL_VENDOR);
545: Con_Printf ("GL_VENDOR: %s\n", gl_vendor);
546: gl_renderer = glGetString (GL_RENDERER);
547: Con_Printf ("GL_RENDERER: %s\n", gl_renderer);
548:
549: gl_version = glGetString (GL_VERSION);
550: Con_Printf ("GL_VERSION: %s\n", gl_version);
551: gl_extensions = glGetString (GL_EXTENSIONS);
552: Con_Printf ("GL_EXTENSIONS: %s\n", gl_extensions);
553:
554: CheckTextureExtensions ();
555:
556: glClearColor (1,0,0,0);
557: glCullFace(GL_FRONT);
558: glEnable(GL_TEXTURE_2D);
559:
560: glEnable(GL_ALPHA_TEST);
561: glAlphaFunc(GL_GREATER, 0.666);
562:
563: glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
564: glShadeModel (GL_FLAT);
565:
566: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
567: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
568: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
569: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
570:
571: glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
572:
573: // glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
574: glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
575:
576: #if 0
577: CheckArrayExtensions ();
578:
579: glEnable (GL_VERTEX_ARRAY_EXT);
580: glEnable (GL_TEXTURE_COORD_ARRAY_EXT);
581: glVertexPointerEXT (3, GL_FLOAT, 0, 0, &glv.x);
582: glTexCoordPointerEXT (2, GL_FLOAT, 0, 0, &glv.s);
583: glColorPointerEXT (3, GL_FLOAT, 0, 0, &glv.r);
584: #endif
585: }
586:
587: /*
588: =================
589: GL_BeginRendering
590:
591: =================
592: */
593: void GL_BeginRendering (int *x, int *y, int *width, int *height)
594: {
595: extern cvar_t gl_clear;
596:
597: *x = *y = 0;
598: *width = WindowRect.right - WindowRect.left;
599: *height = WindowRect.bottom - WindowRect.top;
600:
601: // if (!wglMakeCurrent( maindc, baseRC ))
602: // Sys_Error ("wglMakeCurrent failed");
603:
604: // glViewport (*x, *y, *width, *height);
605: }
606:
607:
608: void GL_EndRendering (void)
609: {
610: if (!scr_skipupdate)
611: SwapBuffers(maindc);
612:
613: // handle the mouse state when windowed if that's changed
614: if (modestate == MS_WINDOWED)
615: {
616: if ((int)_windowed_mouse.value != windowed_mouse)
617: {
618: if (_windowed_mouse.value)
619: {
620: IN_ActivateMouse ();
621: IN_HideMouse ();
622: }
623: else
624: {
625: IN_DeactivateMouse ();
626: IN_ShowMouse ();
627: }
628:
629: windowed_mouse = (int)_windowed_mouse.value;
630: }
631: }
632: }
633:
634:
635:
636: void VID_SetPalette (unsigned char *palette)
637: {
638: byte *pal;
639: int r,g,b,v;
640: int i;
641: unsigned *table;
642:
643:
644: //
645: // 8 8 8 encoding
646: //
647: pal = palette;
648: table = d_8to24table;
649:
650: for (i=0 ; i<256 ; i++)
651: {
652: r = pal[0];
653: g = pal[1];
654: b = pal[2];
655: pal += 3;
656:
657: // v = (255<<24) + (r<<16) + (g<<8) + (b<<0);
658: // v = (255<<0) + (r<<8) + (g<<16) + (b<<24);
659: v = (255<<24) + (r<<0) + (g<<8) + (b<<16);
660: *table++ = v;
661: }
662:
663: d_8to24table[255] &= 0xffffff; // 255 is transparent
664: }
665:
666: BOOL gammaworks;
667: void VID_ShiftPalette (unsigned char *palette)
668: {
669: extern byte ramps[3][256];
670:
671: // VID_SetPalette (palette);
672:
673: // gammaworks = SetDeviceGammaRamp (maindc, ramps);
674: }
675:
676:
677: void VID_SetDefaultMode (void)
678: {
679: IN_DeactivateMouse ();
680: }
681:
682:
683: void VID_Shutdown (void)
684: {
685: HGLRC hRC;
686: HDC hDC;
687:
688: if (vid_initialized)
689: {
690: hRC = wglGetCurrentContext();
691: hDC = wglGetCurrentDC();
692:
693: wglMakeCurrent(NULL, NULL);
694:
695: if (hRC)
696: wglDeleteContext(hRC);
697:
698: if (hDC && dibwindow)
699: ReleaseDC(dibwindow, hDC);
700:
701: if (modestate == MS_FULLDIB)
702: ChangeDisplaySettings (NULL, 0);
703:
704: if (maindc && dibwindow)
705: ReleaseDC (dibwindow, maindc);
706:
707: AppActivate(false, false);
708: }
709: }
710:
711:
712: //==========================================================================
713:
714:
715: BOOL bSetupPixelFormat(HDC hDC)
716: {
717: static PIXELFORMATDESCRIPTOR pfd = {
718: sizeof(PIXELFORMATDESCRIPTOR), // size of this pfd
719: 1, // version number
720: PFD_DRAW_TO_WINDOW // support window
721: | PFD_SUPPORT_OPENGL // support OpenGL
722: | PFD_DOUBLEBUFFER , // double buffered
723: PFD_TYPE_RGBA, // RGBA type
724: 24, // 24-bit color depth
725: 0, 0, 0, 0, 0, 0, // color bits ignored
726: 0, // no alpha buffer
727: 0, // shift bit ignored
728: 0, // no accumulation buffer
729: 0, 0, 0, 0, // accum bits ignored
730: 32, // 32-bit z-buffer
731: 0, // no stencil buffer
732: 0, // no auxiliary buffer
733: PFD_MAIN_PLANE, // main layer
734: 0, // reserved
735: 0, 0, 0 // layer masks ignored
736: };
737: int pixelformat;
738:
739: if ( (pixelformat = ChoosePixelFormat(hDC, &pfd)) == 0 )
740: {
741: MessageBox(NULL, "ChoosePixelFormat failed", "Error", MB_OK);
742: return FALSE;
743: }
744:
745: if (SetPixelFormat(hDC, pixelformat, &pfd) == FALSE)
746: {
747: MessageBox(NULL, "SetPixelFormat failed", "Error", MB_OK);
748: return FALSE;
749: }
750:
751: return TRUE;
752: }
753:
754:
755:
756: byte scantokey[128] =
757: {
758: // 0 1 2 3 4 5 6 7
759: // 8 9 A B C D E F
760: 0 , 27, '1', '2', '3', '4', '5', '6',
761: '7', '8', '9', '0', '-', '=', K_BACKSPACE, 9, // 0
762: 'q', 'w', 'e', 'r', 't', 'y', 'u', 'i',
763: 'o', 'p', '[', ']', 13 , K_CTRL,'a', 's', // 1
764: 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';',
765: '\'' , '`', K_SHIFT,'\\', 'z', 'x', 'c', 'v', // 2
766: 'b', 'n', 'm', ',', '.', '/', K_SHIFT,'*',
767: K_ALT,' ', 0 , K_F1, K_F2, K_F3, K_F4, K_F5, // 3
768: K_F6, K_F7, K_F8, K_F9, K_F10,0 , 0 , K_HOME,
769: K_UPARROW,K_PGUP,'-',K_LEFTARROW,'5',K_RIGHTARROW,'+',K_END, //4
770: K_DOWNARROW,K_PGDN,K_INS,K_DEL,0,0, 0, K_F11,
771: K_F12,0 , 0 , 0 , 0 , 0 , 0 , 0, // 5
772: 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0,
773: 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0, // 6
774: 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0,
775: 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 // 7
776: };
777:
778: byte shiftscantokey[128] =
779: {
780: // 0 1 2 3 4 5 6 7
781: // 8 9 A B C D E F
782: 0 , 27, '!', '@', '#', '$', '%', '^',
783: '&', '*', '(', ')', '_', '+', K_BACKSPACE, 9, // 0
784: 'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I',
785: 'O', 'P', '{', '}', 13 , K_CTRL,'A', 'S', // 1
786: 'D', 'F', 'G', 'H', 'J', 'K', 'L', ':',
787: '"' , '~', K_SHIFT,'|', 'Z', 'X', 'C', 'V', // 2
788: 'B', 'N', 'M', '<', '>', '?', K_SHIFT,'*',
789: K_ALT,' ', 0 , K_F1, K_F2, K_F3, K_F4, K_F5, // 3
790: K_F6, K_F7, K_F8, K_F9, K_F10,0 , 0 , K_HOME,
791: K_UPARROW,K_PGUP,'_',K_LEFTARROW,'%',K_RIGHTARROW,'+',K_END, //4
792: K_DOWNARROW,K_PGDN,K_INS,K_DEL,0,0, 0, K_F11,
793: K_F12,0 , 0 , 0 , 0 , 0 , 0 , 0, // 5
794: 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0,
795: 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0, // 6
796: 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0,
797: 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 // 7
798: };
799:
800:
801: /*
802: =======
803: MapKey
804:
805: Map from windows to quake keynums
806: =======
807: */
808: int MapKey (int key)
809: {
810: key = (key>>16)&255;
811: if (key > 127)
812: return 0;
813: return scantokey[key];
814: }
815:
816: /*
817: ===================================================================
818:
819: MAIN WINDOW
820:
821: ===================================================================
822: */
823:
824: /*
825: ================
826: ClearAllStates
827: ================
828: */
829: void ClearAllStates (void)
830: {
831: int i;
832:
833: // send an up event for each key, to make sure the server clears them all
834: for (i=0 ; i<256 ; i++)
835: {
836: Key_Event (i, false);
837: }
838:
839: Key_ClearStates ();
840: IN_ClearStates ();
841: }
842:
843: void AppActivate(BOOL fActive, BOOL minimize)
844: /****************************************************************************
845: *
846: * Function: AppActivate
847: * Parameters: fActive - True if app is activating
848: *
849: * Description: If the application is activating, then swap the system
850: * into SYSPAL_NOSTATIC mode so that our palettes will display
851: * correctly.
852: *
853: ****************************************************************************/
854: {
855: HDC hdc;
856: int i, t;
857: static BOOL sound_active;
858:
859: ActiveApp = fActive;
860: Minimized = minimize;
861:
862: // enable/disable sound on focus gain/loss
863: if (!ActiveApp && sound_active)
864: {
865: S_BlockSound ();
866: sound_active = false;
867: }
868: else if (ActiveApp && !sound_active)
869: {
870: S_UnblockSound ();
871: sound_active = true;
872: }
873:
874: if (fActive)
875: {
876: if (modestate == MS_FULLDIB)
877: {
878: IN_ActivateMouse ();
879: IN_HideMouse ();
880: }
881: else if ((modestate == MS_WINDOWED) && _windowed_mouse.value)
882: {
883: IN_ActivateMouse ();
884: IN_HideMouse ();
885: }
886: }
887:
888: if (!fActive)
889: {
890: if (modestate == MS_FULLDIB)
891: {
892: IN_DeactivateMouse ();
893: IN_ShowMouse ();
894: }
895: else if ((modestate == MS_WINDOWED) && _windowed_mouse.value)
896: {
897: IN_DeactivateMouse ();
898: IN_ShowMouse ();
899: }
900: }
901: }
902:
903:
904: /* main window procedure */
905: LONG WINAPI MainWndProc (
906: HWND hWnd,
907: UINT uMsg,
908: WPARAM wParam,
909: LPARAM lParam)
910: {
911: LONG lRet = 1;
912: int fwKeys, xPos, yPos, fActive, fMinimized, temp;
913:
914: switch (uMsg)
915: {
916: case WM_CREATE:
917: break;
918:
919: case WM_MOVE:
920: window_x = (int) LOWORD(lParam);
921: window_y = (int) HIWORD(lParam);
922: VID_UpdateWindowStatus ();
923: break;
924:
925: case WM_KEYDOWN:
926: case WM_SYSKEYDOWN:
927: Key_Event (MapKey(lParam), true);
928: break;
929:
930: case WM_KEYUP:
931: case WM_SYSKEYUP:
932: Key_Event (MapKey(lParam), false);
933: break;
934:
935: case WM_SYSCHAR:
936: // keep Alt-Space from happening
937: break;
938:
939: // this is complicated because Win32 seems to pack multiple mouse events into
940: // one update sometimes, so we always check all states and look for events
941: case WM_LBUTTONDOWN:
942: case WM_LBUTTONUP:
943: case WM_RBUTTONDOWN:
944: case WM_RBUTTONUP:
945: case WM_MBUTTONDOWN:
946: case WM_MBUTTONUP:
947: case WM_MOUSEMOVE:
948: temp = 0;
949:
950: if (wParam & MK_LBUTTON)
951: temp |= 1;
952:
953: if (wParam & MK_RBUTTON)
954: temp |= 2;
955:
956: if (wParam & MK_MBUTTON)
957: temp |= 4;
958:
959: IN_MouseEvent (temp);
960:
961: break;
962:
963:
964: case WM_SIZE:
965: break;
966:
967: case WM_CLOSE:
968: if (MessageBox (mainwindow, "Are you sure you want to quit?", "Confirm Exit",
969: MB_YESNO | MB_SETFOREGROUND | MB_ICONQUESTION) == IDYES)
970: {
971: Sys_Quit ();
972: }
973:
974: break;
975:
976: case WM_ACTIVATE:
977: fActive = LOWORD(wParam);
978: fMinimized = (BOOL) HIWORD(wParam);
979: AppActivate(!(fActive == WA_INACTIVE), fMinimized);
980:
981: // fix the leftover Alt from any Alt-Tab or the like that switched us away
982: ClearAllStates ();
983:
984: break;
985:
986: case WM_DESTROY:
987: {
988: if (dibwindow)
989: DestroyWindow (dibwindow);
990:
991: PostQuitMessage (0);
992: }
993: break;
994:
995: case MM_MCINOTIFY:
996: lRet = CDAudio_MessageHandler (hWnd, uMsg, wParam, lParam);
997: break;
998:
999: default:
1000: /* pass all unhandled messages to DefWindowProc */
1001: lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
1002: break;
1003: }
1004:
1005: /* return 1 if handled message, 0 if not */
1006: return lRet;
1007: }
1008:
1009:
1010: /*
1011: =================
1012: VID_NumModes
1013: =================
1014: */
1015: int VID_NumModes (void)
1016: {
1017: return nummodes;
1018: }
1019:
1020:
1021: /*
1022: =================
1023: VID_GetModePtr
1024: =================
1025: */
1026: vmode_t *VID_GetModePtr (int modenum)
1027: {
1028:
1029: if ((modenum >= 0) && (modenum < nummodes))
1030: return &modelist[modenum];
1031: else
1032: return &badmode;
1033: }
1034:
1035:
1036: /*
1037: =================
1038: VID_GetModeDescription
1039: =================
1040: */
1041: char *VID_GetModeDescription (int mode)
1042: {
1043: char *pinfo;
1044: vmode_t *pv;
1045: static char temp[100];
1046:
1047: if ((mode < 0) || (mode >= nummodes))
1048: return NULL;
1049:
1050: if (!leavecurrentmode)
1051: {
1052: pv = VID_GetModePtr (mode);
1053: pinfo = pv->modedesc;
1054: }
1055: else
1056: {
1057: sprintf (temp, "Desktop resolution (%dx%d)",
1058: modelist[MODE_FULLSCREEN_DEFAULT].width,
1059: modelist[MODE_FULLSCREEN_DEFAULT].height);
1060: pinfo = temp;
1061: }
1062:
1063: return pinfo;
1064: }
1065:
1066:
1067: // KJB: Added this to return the mode driver name in description for console
1068:
1069: char *VID_GetExtModeDescription (int mode)
1070: {
1071: static char pinfo[40];
1072: vmode_t *pv;
1073:
1074: if ((mode < 0) || (mode >= nummodes))
1075: return NULL;
1076:
1077: pv = VID_GetModePtr (mode);
1078: if (modelist[mode].type == MS_FULLDIB)
1079: {
1080: if (!leavecurrentmode)
1081: {
1082: sprintf(pinfo,"%s fullscreen", pv->modedesc);
1083: }
1084: else
1085: {
1086: sprintf (pinfo, "Desktop resolution (%dx%d)",
1087: modelist[MODE_FULLSCREEN_DEFAULT].width,
1088: modelist[MODE_FULLSCREEN_DEFAULT].height);
1089: }
1090: }
1091: else
1092: {
1093: if (modestate == MS_WINDOWED)
1094: sprintf(pinfo, "%s windowed", pv->modedesc);
1095: else
1096: sprintf(pinfo, "windowed");
1097: }
1098:
1099: return pinfo;
1100: }
1101:
1102:
1103: /*
1104: =================
1105: VID_DescribeCurrentMode_f
1106: =================
1107: */
1108: void VID_DescribeCurrentMode_f (void)
1109: {
1110: Con_Printf ("%s\n", VID_GetExtModeDescription (vid_modenum));
1111: }
1112:
1113:
1114: /*
1115: =================
1116: VID_NumModes_f
1117: =================
1118: */
1119: void VID_NumModes_f (void)
1120: {
1121:
1122: if (nummodes == 1)
1123: Con_Printf ("%d video mode is available\n", nummodes);
1124: else
1125: Con_Printf ("%d video modes are available\n", nummodes);
1126: }
1127:
1128:
1129: /*
1130: =================
1131: VID_DescribeMode_f
1132: =================
1133: */
1134: void VID_DescribeMode_f (void)
1135: {
1136: int t, modenum;
1137:
1138: modenum = Q_atoi (Cmd_Argv(1));
1139:
1140: t = leavecurrentmode;
1141: leavecurrentmode = 0;
1142:
1143: Con_Printf ("%s\n", VID_GetExtModeDescription (modenum));
1144:
1145: leavecurrentmode = t;
1146: }
1147:
1148:
1149: /*
1150: =================
1151: VID_DescribeModes_f
1152: =================
1153: */
1154: void VID_DescribeModes_f (void)
1155: {
1156: int i, lnummodes, t;
1157: char *pinfo;
1158: vmode_t *pv;
1159:
1160: lnummodes = VID_NumModes ();
1161:
1162: t = leavecurrentmode;
1163: leavecurrentmode = 0;
1164:
1165: for (i=1 ; i<lnummodes ; i++)
1166: {
1167: pv = VID_GetModePtr (i);
1168: pinfo = VID_GetExtModeDescription (i);
1169: Con_Printf ("%2d: %s\n", i, pinfo);
1170: }
1171:
1172: leavecurrentmode = t;
1173: }
1174:
1175:
1176: void VID_InitDIB (HINSTANCE hInstance)
1177: {
1178: WNDCLASS wc;
1179: HDC hdc;
1180: int i;
1181:
1182: /* Register the frame class */
1183: wc.style = 0;
1184: wc.lpfnWndProc = (WNDPROC)MainWndProc;
1185: wc.cbClsExtra = 0;
1186: wc.cbWndExtra = 0;
1187: wc.hInstance = hInstance;
1188: wc.hIcon = 0;
1189: wc.hCursor = LoadCursor (NULL,IDC_ARROW);
1190: wc.hbrBackground = NULL;
1191: wc.lpszMenuName = 0;
1192: wc.lpszClassName = "WinQuake";
1193:
1194: if (!RegisterClass (&wc) )
1195: Sys_Error ("Couldn't register window class");
1196:
1197: modelist[0].type = MS_WINDOWED;
1198:
1199: if (COM_CheckParm("-width"))
1200: modelist[0].width = Q_atoi(com_argv[COM_CheckParm("-width")+1]);
1201: else
1202: modelist[0].width = 640;
1203:
1204: if (modelist[0].width < 320)
1205: modelist[0].width = 320;
1206:
1207: if (COM_CheckParm("-height"))
1208: modelist[0].height= Q_atoi(com_argv[COM_CheckParm("-height")+1]);
1209: else
1210: modelist[0].height = modelist[0].width * 240/320;
1211:
1212: if (modelist[0].height < 240)
1213: modelist[0].height = 240;
1214:
1215: sprintf (modelist[0].modedesc, "%dx%d",
1216: modelist[0].width, modelist[0].height);
1217:
1218: modelist[0].modenum = MODE_WINDOWED;
1219: modelist[0].dib = 1;
1220: modelist[0].fullscreen = 0;
1221: modelist[0].halfscreen = 0;
1222: modelist[0].bpp = 0;
1223:
1224: nummodes = 1;
1225: }
1226:
1227:
1228: /*
1229: =================
1230: VID_InitFullDIB
1231: =================
1232: */
1233: void VID_InitFullDIB (HINSTANCE hInstance)
1234: {
1235: DEVMODE devmode;
1236: int i, modenum, cmodes, originalnummodes, existingmode, numlowresmodes;
1237: int j, bpp, done;
1238: BOOL stat;
1239:
1240: // enumerate >8 bpp modes
1241: originalnummodes = nummodes;
1242: modenum = 0;
1243:
1244: do
1245: {
1246: stat = EnumDisplaySettings (NULL, modenum, &devmode);
1247:
1248: if ((devmode.dmBitsPerPel >= 15) &&
1249: (devmode.dmPelsWidth <= MAXWIDTH) &&
1250: (devmode.dmPelsHeight <= MAXHEIGHT) &&
1251: (nummodes < MAX_MODE_LIST))
1252: {
1253: devmode.dmFields = DM_BITSPERPEL |
1254: DM_PELSWIDTH |
1255: DM_PELSHEIGHT;
1256:
1257: if (ChangeDisplaySettings (&devmode, CDS_TEST | CDS_FULLSCREEN) ==
1258: DISP_CHANGE_SUCCESSFUL)
1259: {
1260: modelist[nummodes].type = MS_FULLDIB;
1261: modelist[nummodes].width = devmode.dmPelsWidth;
1262: modelist[nummodes].height = devmode.dmPelsHeight;
1263: modelist[nummodes].modenum = 0;
1264: modelist[nummodes].halfscreen = 0;
1265: modelist[nummodes].dib = 1;
1266: modelist[nummodes].fullscreen = 1;
1267: modelist[nummodes].bpp = devmode.dmBitsPerPel;
1268: sprintf (modelist[nummodes].modedesc, "%dx%dx%d",
1269: devmode.dmPelsWidth, devmode.dmPelsHeight,
1270: devmode.dmBitsPerPel);
1271:
1272: // if the width is more than twice the height, reduce it by half because this
1273: // is probably a dual-screen monitor
1274: if (!COM_CheckParm("-noadjustaspect"))
1275: {
1276: if (modelist[nummodes].width > (modelist[nummodes].height << 1))
1277: {
1278: modelist[nummodes].width >>= 1;
1279: modelist[nummodes].halfscreen = 1;
1280: sprintf (modelist[nummodes].modedesc, "%dx%dx%d",
1281: modelist[nummodes].width,
1282: modelist[nummodes].height,
1283: modelist[nummodes].bpp);
1284: }
1285: }
1286:
1287: for (i=originalnummodes, existingmode = 0 ; i<nummodes ; i++)
1288: {
1289: if ((modelist[nummodes].width == modelist[i].width) &&
1290: (modelist[nummodes].height == modelist[i].height) &&
1291: (modelist[nummodes].bpp == modelist[i].bpp))
1292: {
1293: existingmode = 1;
1294: break;
1295: }
1296: }
1297:
1298: if (!existingmode)
1299: {
1300: nummodes++;
1301: }
1302: }
1303: }
1304:
1305: modenum++;
1306: } while (stat);
1307:
1308: // see if there are any low-res modes that aren't being reported
1309: numlowresmodes = sizeof(lowresmodes) / sizeof(lowresmodes[0]);
1310: bpp = 16;
1311: done = 0;
1312:
1313: do
1314: {
1315: for (j=0 ; (j<numlowresmodes) && (nummodes < MAX_MODE_LIST) ; j++)
1316: {
1317: devmode.dmBitsPerPel = bpp;
1318: devmode.dmPelsWidth = lowresmodes[j].width;
1319: devmode.dmPelsHeight = lowresmodes[j].height;
1320: devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
1321:
1322: if (ChangeDisplaySettings (&devmode, CDS_TEST | CDS_FULLSCREEN) ==
1323: DISP_CHANGE_SUCCESSFUL)
1324: {
1325: modelist[nummodes].type = MS_FULLDIB;
1326: modelist[nummodes].width = devmode.dmPelsWidth;
1327: modelist[nummodes].height = devmode.dmPelsHeight;
1328: modelist[nummodes].modenum = 0;
1329: modelist[nummodes].halfscreen = 0;
1330: modelist[nummodes].dib = 1;
1331: modelist[nummodes].fullscreen = 1;
1332: modelist[nummodes].bpp = devmode.dmBitsPerPel;
1333: sprintf (modelist[nummodes].modedesc, "%dx%dx%d",
1334: devmode.dmPelsWidth, devmode.dmPelsHeight,
1335: devmode.dmBitsPerPel);
1336:
1337: for (i=originalnummodes, existingmode = 0 ; i<nummodes ; i++)
1338: {
1339: if ((modelist[nummodes].width == modelist[i].width) &&
1340: (modelist[nummodes].height == modelist[i].height) &&
1341: (modelist[nummodes].bpp == modelist[i].bpp))
1342: {
1343: existingmode = 1;
1344: break;
1345: }
1346: }
1347:
1348: if (!existingmode)
1349: {
1350: nummodes++;
1351: }
1352: }
1353: }
1354: switch (bpp)
1355: {
1356: case 16:
1357: bpp = 32;
1358: break;
1359:
1360: case 32:
1361: bpp = 24;
1362: break;
1363:
1364: case 24:
1365: done = 1;
1366: break;
1367: }
1368: } while (!done);
1369:
1370: if (nummodes == originalnummodes)
1371: Con_SafePrintf ("No fullscreen DIB modes found\n");
1372: }
1373:
1374:
1375: /*
1376: ===================
1377: VID_Init
1378: ===================
1379: */
1380: void VID_Init (unsigned char *palette)
1381: {
1382: int i, existingmode;
1383: int basenummodes, width, height, bpp, findbpp, done;
1384: byte *ptmp;
1385: char gldir[MAX_OSPATH];
1386: HDC hdc;
1387: DEVMODE devmode;
1388:
1389: Cvar_RegisterVariable (&vid_mode);
1390: Cvar_RegisterVariable (&vid_wait);
1391: Cvar_RegisterVariable (&vid_nopageflip);
1392: Cvar_RegisterVariable (&_vid_wait_override);
1393: Cvar_RegisterVariable (&_vid_default_mode);
1394: Cvar_RegisterVariable (&_vid_default_mode_win);
1395: Cvar_RegisterVariable (&vid_config_x);
1396: Cvar_RegisterVariable (&vid_config_y);
1397: Cvar_RegisterVariable (&vid_stretch_by_2);
1398: Cvar_RegisterVariable (&_windowed_mouse);
1399: Cvar_RegisterVariable (&gl_ztrick);
1400:
1401: Cmd_AddCommand ("vid_nummodes", VID_NumModes_f);
1402: Cmd_AddCommand ("vid_describecurrentmode", VID_DescribeCurrentMode_f);
1403: Cmd_AddCommand ("vid_describemode", VID_DescribeMode_f);
1404: Cmd_AddCommand ("vid_describemodes", VID_DescribeModes_f);
1405:
1406: hIcon = LoadIcon (global_hInstance, MAKEINTRESOURCE (IDI_ICON2));
1407:
1408: VID_InitDIB (global_hInstance);
1409: basenummodes = nummodes = 1;
1410:
1411: VID_InitFullDIB (global_hInstance);
1412:
1413: if (COM_CheckParm("-window"))
1414: {
1415: hdc = GetDC (NULL);
1416:
1417: if (GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE)
1418: {
1419: Sys_Error ("Can't run in non-RGB mode");
1420: }
1421:
1422: ReleaseDC (NULL, hdc);
1423:
1424: windowed = true;
1425:
1426: vid_default = MODE_WINDOWED;
1427: }
1428: else
1429: {
1430: if (nummodes == 1)
1431: Sys_Error ("No RGB fullscreen modes available");
1432:
1433: windowed = false;
1434:
1435: if (COM_CheckParm("-mode"))
1436: {
1437: vid_default = Q_atoi(com_argv[COM_CheckParm("-mode")+1]);
1438: }
1439: else
1440: {
1441: if (COM_CheckParm("-current"))
1442: {
1443: modelist[MODE_FULLSCREEN_DEFAULT].width =
1444: GetSystemMetrics (SM_CXSCREEN);
1445: modelist[MODE_FULLSCREEN_DEFAULT].height =
1446: GetSystemMetrics (SM_CYSCREEN);
1447: vid_default = MODE_FULLSCREEN_DEFAULT;
1448: leavecurrentmode = 1;
1449: }
1450: else
1451: {
1452: if (COM_CheckParm("-width"))
1453: {
1454: width = Q_atoi(com_argv[COM_CheckParm("-width")+1]);
1455: }
1456: else
1457: {
1458: width = 640;
1459: }
1460:
1461: if (COM_CheckParm("-bpp"))
1462: {
1463: bpp = Q_atoi(com_argv[COM_CheckParm("-bpp")+1]);
1464: findbpp = 0;
1465: }
1466: else
1467: {
1468: bpp = 15;
1469: findbpp = 1;
1470: }
1471:
1472: if (COM_CheckParm("-height"))
1473: height = Q_atoi(com_argv[COM_CheckParm("-height")+1]);
1474:
1475: // if they want to force it, add the specified mode to the list
1476: if (COM_CheckParm("-force") && (nummodes < MAX_MODE_LIST))
1477: {
1478: modelist[nummodes].type = MS_FULLDIB;
1479: modelist[nummodes].width = width;
1480: modelist[nummodes].height = height;
1481: modelist[nummodes].modenum = 0;
1482: modelist[nummodes].halfscreen = 0;
1483: modelist[nummodes].dib = 1;
1484: modelist[nummodes].fullscreen = 1;
1485: modelist[nummodes].bpp = bpp;
1486: sprintf (modelist[nummodes].modedesc, "%dx%dx%d",
1487: devmode.dmPelsWidth, devmode.dmPelsHeight,
1488: devmode.dmBitsPerPel);
1489:
1490: for (i=nummodes, existingmode = 0 ; i<nummodes ; i++)
1491: {
1492: if ((modelist[nummodes].width == modelist[i].width) &&
1493: (modelist[nummodes].height == modelist[i].height) &&
1494: (modelist[nummodes].bpp == modelist[i].bpp))
1495: {
1496: existingmode = 1;
1497: break;
1498: }
1499: }
1500:
1501: if (!existingmode)
1502: {
1503: nummodes++;
1504: }
1505: }
1506:
1507: done = 0;
1508:
1509: do
1510: {
1511: if (COM_CheckParm("-height"))
1512: {
1513: height = Q_atoi(com_argv[COM_CheckParm("-height")+1]);
1514:
1515: for (i=1, vid_default=0 ; i<nummodes ; i++)
1516: {
1517: if ((modelist[i].width == width) &&
1518: (modelist[i].height == height) &&
1519: (modelist[i].bpp == bpp))
1520: {
1521: vid_default = i;
1522: done = 1;
1523: break;
1524: }
1525: }
1526: }
1527: else
1528: {
1529: for (i=1, vid_default=0 ; i<nummodes ; i++)
1530: {
1531: if ((modelist[i].width == width) && (modelist[i].bpp == bpp))
1532: {
1533: vid_default = i;
1534: done = 1;
1535: break;
1536: }
1537: }
1538: }
1539:
1540: if (!done)
1541: {
1542: if (findbpp)
1543: {
1544: switch (bpp)
1545: {
1546: case 15:
1547: bpp = 16;
1548: break;
1549: case 16:
1550: bpp = 32;
1551: break;
1552: case 32:
1553: bpp = 24;
1554: break;
1555: case 24:
1556: done = 1;
1557: break;
1558: }
1559: }
1560: else
1561: {
1562: done = 1;
1563: }
1564: }
1565: } while (!done);
1566:
1567: if (!vid_default)
1568: {
1569: Sys_Error ("Specified video mode not available");
1570: }
1571: }
1572: }
1573: }
1574:
1575: vid_initialized = true;
1576:
1577: vid.maxwarpwidth = WARP_WIDTH;
1578: vid.maxwarpheight = WARP_HEIGHT;
1579: vid.colormap = host_colormap;
1580: vid.fullbright = 256 - LittleLong (*((int *)vid.colormap + 2048));
1581:
1582: DestroyWindow (hwnd_dialog);
1583:
1584: VID_SetMode (vid_default, palette);
1585:
1586: maindc = GetDC(mainwindow);
1587: bSetupPixelFormat(maindc);
1588:
1589: baseRC = wglCreateContext( maindc );
1590: if (!baseRC)
1591: Sys_Error ("wglCreateContect failed");
1592: if (!wglMakeCurrent( maindc, baseRC ))
1593: Sys_Error ("wglMakeCurrent failed");
1594:
1595: GL_Init ();
1596:
1597: sprintf (gldir, "%s/glquake", com_gamedir);
1598: Sys_mkdir (gldir);
1599:
1600: vid_realmode = vid_modenum;
1601:
1602: VID_SetPalette (palette);
1603:
1604: vid_menudrawfn = VID_MenuDraw;
1605: vid_menukeyfn = VID_MenuKey;
1606:
1607: strcpy (badmode.modedesc, "Bad mode");
1608: }
1609:
1610:
1611: //========================================================
1612: // Video menu stuff
1613: //========================================================
1614:
1615: extern void M_Menu_Options_f (void);
1616: extern void M_Print (int cx, int cy, char *str);
1617: extern void M_PrintWhite (int cx, int cy, char *str);
1618: extern void M_DrawCharacter (int cx, int line, int num);
1619: extern void M_DrawTransPic (int x, int y, qpic_t *pic);
1620: extern void M_DrawPic (int x, int y, qpic_t *pic);
1621:
1622: static int vid_line, vid_wmodes;
1623:
1624: typedef struct
1625: {
1626: int modenum;
1627: char *desc;
1628: int iscur;
1629: } modedesc_t;
1630:
1631: #define MAX_COLUMN_SIZE 9
1632: #define MODE_AREA_HEIGHT (MAX_COLUMN_SIZE + 2)
1633: #define MAX_MODEDESCS (MAX_COLUMN_SIZE*3)
1634:
1635: static modedesc_t modedescs[MAX_MODEDESCS];
1636:
1637: /*
1638: ================
1639: VID_MenuDraw
1640: ================
1641: */
1642: void VID_MenuDraw (void)
1643: {
1644: qpic_t *p;
1645: char *ptr;
1646: int lnummodes, i, j, k, column, row, dup, dupmode;
1647: char temp[100];
1648: vmode_t *pv;
1649:
1650: p = Draw_CachePic ("gfx/vidmodes.lmp");
1651: M_DrawPic ( (320-p->width)/2, 4, p);
1652:
1653: vid_wmodes = 0;
1654: lnummodes = VID_NumModes ();
1655:
1656: for (i=1 ; (i<lnummodes) && (vid_wmodes < MAX_MODEDESCS) ; i++)
1657: {
1658: ptr = VID_GetModeDescription (i);
1659: pv = VID_GetModePtr (i);
1660:
1661: k = vid_wmodes;
1662:
1663: modedescs[k].modenum = i;
1664: modedescs[k].desc = ptr;
1665: modedescs[k].iscur = 0;
1666:
1667: if (i == vid_modenum)
1668: modedescs[k].iscur = 1;
1669:
1670: vid_wmodes++;
1671:
1672: }
1673:
1674: if (vid_wmodes > 0)
1675: {
1676: M_Print (2*8, 36+0*8, "Fullscreen Modes (WIDTHxHEIGHTxBPP)");
1677:
1678: column = 8;
1679: row = 36+2*8;
1680:
1681: for (i=0 ; i<vid_wmodes ; i++)
1682: {
1683: if (modedescs[i].iscur)
1684: M_PrintWhite (column, row, modedescs[i].desc);
1685: else
1686: M_Print (column, row, modedescs[i].desc);
1687:
1688: column += 13*8;
1689:
1690: if ((i % VID_ROW_SIZE) == (VID_ROW_SIZE - 1))
1691: {
1692: column = 8;
1693: row += 8;
1694: }
1695: }
1696: }
1697:
1698: M_Print (3*8, 36 + MODE_AREA_HEIGHT * 8 + 8*2,
1699: "Video modes must be set from the");
1700: M_Print (3*8, 36 + MODE_AREA_HEIGHT * 8 + 8*3,
1701: "command line with -width <width>");
1702: M_Print (3*8, 36 + MODE_AREA_HEIGHT * 8 + 8*4,
1703: "and -bpp <bits-per-pixel>");
1704: M_Print (3*8, 36 + MODE_AREA_HEIGHT * 8 + 8*6,
1705: "Select windowed mode with -window");
1706: }
1707:
1708:
1709: /*
1710: ================
1711: VID_MenuKey
1712: ================
1713: */
1714: void VID_MenuKey (int key)
1715: {
1716: switch (key)
1717: {
1718: case K_ESCAPE:
1719: S_LocalSound ("misc/menu1.wav");
1720: M_Menu_Options_f ();
1721: break;
1722:
1723: default:
1724: break;
1725: }
1726: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.