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