![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vid_menu.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake II] / quake2 / win32|
Return to vid_menu.c CVS log | Up to [Quake II] / quake2 / win32 |
1.1 root 1: #include "../client/client.h"
2: #include "../client/qmenu.h"
3:
4: #define REF_SOFT 0
5: #define REF_OPENGL 1
6: #define REF_3DFX 2
7: #define REF_POWERVR 3
8: #define REF_VERITE 4
9:
10: extern cvar_t *vid_ref;
11: extern cvar_t *vid_fullscreen;
12: extern cvar_t *vid_gamma;
13: extern cvar_t *scr_viewsize;
14:
15: static cvar_t *gl_mode;
16: static cvar_t *gl_driver;
17: static cvar_t *gl_picmip;
18: static cvar_t *gl_ext_palettedtexture;
1.1.1.2 ! root 19: static cvar_t *gl_finish;
1.1 root 20:
21: static cvar_t *sw_mode;
22: static cvar_t *sw_stipplealpha;
23:
24: extern void M_ForceMenuOff( void );
25:
26: /*
27: ====================================================================
28:
29: MENU INTERACTION
30:
31: ====================================================================
32: */
33: #define SOFTWARE_MENU 0
34: #define OPENGL_MENU 1
35:
36: static menuframework_s s_software_menu;
37: static menuframework_s s_opengl_menu;
38: static menuframework_s *s_current_menu;
39: static int s_current_menu_index;
40:
41: static menulist_s s_mode_list[2];
42: static menulist_s s_ref_list[2];
43: static menuslider_s s_tq_slider;
44: static menuslider_s s_screensize_slider[2];
45: static menuslider_s s_brightness_slider[2];
46: static menulist_s s_fs_box[2];
47: static menulist_s s_stipple_box;
48: static menulist_s s_paletted_texture_box;
1.1.1.2 ! root 49: static menulist_s s_finish_box;
1.1 root 50: static menuaction_s s_cancel_action[2];
51: static menuaction_s s_defaults_action[2];
52:
53: static void DriverCallback( void *unused )
54: {
55: s_ref_list[!s_current_menu_index].curvalue = s_ref_list[s_current_menu_index].curvalue;
56:
57: if ( s_ref_list[s_current_menu_index].curvalue == 0 )
58: {
59: s_current_menu = &s_software_menu;
60: s_current_menu_index = 0;
61: }
62: else
63: {
64: s_current_menu = &s_opengl_menu;
65: s_current_menu_index = 1;
66: }
67:
68: }
69:
70: static void ScreenSizeCallback( void *s )
71: {
72: menuslider_s *slider = ( menuslider_s * ) s;
73:
74: Cvar_SetValue( "viewsize", slider->curvalue * 10 );
75: }
76:
77: static void BrightnessCallback( void *s )
78: {
79: menuslider_s *slider = ( menuslider_s * ) s;
80:
81: if ( s_current_menu_index == SOFTWARE_MENU )
82: s_brightness_slider[1].curvalue = s_brightness_slider[0].curvalue;
83: else
84: s_brightness_slider[0].curvalue = s_brightness_slider[1].curvalue;
85:
86: if ( stricmp( vid_ref->string, "soft" ) == 0 )
87: {
88: float gamma = ( 0.8 - ( slider->curvalue/10.0 - 0.5 ) ) + 0.5;
89:
90: Cvar_SetValue( "vid_gamma", gamma );
91: }
92: }
93:
94: static void ResetDefaults( void *unused )
95: {
96: VID_MenuInit();
97: }
98:
99: static void ApplyChanges( void *unused )
100: {
101: float gamma;
102:
103: /*
104: ** make values consistent
105: */
106: s_fs_box[!s_current_menu_index].curvalue = s_fs_box[s_current_menu_index].curvalue;
107: s_brightness_slider[!s_current_menu_index].curvalue = s_brightness_slider[s_current_menu_index].curvalue;
108: s_ref_list[!s_current_menu_index].curvalue = s_ref_list[s_current_menu_index].curvalue;
109:
110: /*
111: ** invert sense so greater = brighter, and scale to a range of 0.5 to 1.3
112: */
113: gamma = ( 0.8 - ( s_brightness_slider[s_current_menu_index].curvalue/10.0 - 0.5 ) ) + 0.5;
114:
115: Cvar_SetValue( "vid_gamma", gamma );
116: Cvar_SetValue( "sw_stipplealpha", s_stipple_box.curvalue );
117: Cvar_SetValue( "gl_picmip", 3 - s_tq_slider.curvalue );
118: Cvar_SetValue( "vid_fullscreen", s_fs_box[s_current_menu_index].curvalue );
119: Cvar_SetValue( "gl_ext_palettedtexture", s_paletted_texture_box.curvalue );
1.1.1.2 ! root 120: Cvar_SetValue( "gl_finish", s_finish_box.curvalue );
1.1 root 121: Cvar_SetValue( "sw_mode", s_mode_list[SOFTWARE_MENU].curvalue );
122: Cvar_SetValue( "gl_mode", s_mode_list[OPENGL_MENU].curvalue );
123:
124: switch ( s_ref_list[s_current_menu_index].curvalue )
125: {
126: case REF_SOFT:
127: Cvar_Set( "vid_ref", "soft" );
128: break;
129: case REF_OPENGL:
130: Cvar_Set( "vid_ref", "gl" );
131: Cvar_Set( "gl_driver", "opengl32" );
132: break;
133: case REF_3DFX:
134: Cvar_Set( "vid_ref", "gl" );
135: Cvar_Set( "gl_driver", "3dfxgl" );
136: break;
137: case REF_POWERVR:
138: Cvar_Set( "vid_ref", "gl" );
139: Cvar_Set( "gl_driver", "pvrgl" );
140: break;
141: case REF_VERITE:
142: Cvar_Set( "vid_ref", "gl" );
143: Cvar_Set( "gl_driver", "veritegl" );
144: break;
145: }
146:
147: /*
148: ** update appropriate stuff if we're running OpenGL and gamma
149: ** has been modified
150: */
151: if ( stricmp( vid_ref->string, "gl" ) == 0 )
152: {
153: if ( vid_gamma->modified )
154: {
155: vid_ref->modified = true;
156: if ( stricmp( gl_driver->string, "3dfxgl" ) == 0 )
157: {
158: char envbuffer[1024];
159: float g;
160:
161: vid_ref->modified = true;
162:
163: g = 2.00 * ( 0.8 - ( vid_gamma->value - 0.5 ) ) + 1.0F;
164: Com_sprintf( envbuffer, sizeof(envbuffer), "SSTV2_GAMMA=%f", g );
165: putenv( envbuffer );
166: Com_sprintf( envbuffer, sizeof(envbuffer), "SST_GAMMA=%f", g );
167: putenv( envbuffer );
168:
169: vid_gamma->modified = false;
170: }
171: }
172:
173: if ( gl_driver->modified )
174: vid_ref->modified = true;
175: }
176:
177: M_ForceMenuOff();
178: }
179:
180: static void CancelChanges( void *unused )
181: {
182: extern void M_PopMenu( void );
183:
184: M_PopMenu();
185: }
186:
187: /*
188: ** VID_MenuInit
189: */
190: void VID_MenuInit( void )
191: {
192: static const char *resolutions[] =
193: {
194: "[320 240 ]",
195: "[400 300 ]",
196: "[512 384 ]",
197: "[640 480 ]",
198: "[800 600 ]",
199: "[960 720 ]",
200: "[1024 768 ]",
201: "[1152 864 ]",
202: "[1280 960 ]",
203: "[1600 1200]",
204: 0
205: };
206: static const char *refs[] =
207: {
208: "[software ]",
209: "[default OpenGL]",
210: "[3Dfx OpenGL ]",
211: "[PowerVR OpenGL]",
212: // "[Rendition OpenGL]",
213: 0
214: };
215: static const char *yesno_names[] =
216: {
217: "no",
218: "yes",
219: 0
220: };
221: int i;
222:
223: if ( !gl_driver )
224: gl_driver = Cvar_Get( "gl_driver", "opengl32", 0 );
225: if ( !gl_picmip )
226: gl_picmip = Cvar_Get( "gl_picmip", "0", 0 );
227: if ( !gl_mode )
228: gl_mode = Cvar_Get( "gl_mode", "3", 0 );
229: if ( !sw_mode )
230: sw_mode = Cvar_Get( "sw_mode", "0", 0 );
231: if ( !gl_ext_palettedtexture )
232: gl_ext_palettedtexture = Cvar_Get( "gl_ext_palettedtexture", "1", CVAR_ARCHIVE );
1.1.1.2 ! root 233: if ( !gl_finish )
! 234: gl_finish = Cvar_Get( "gl_finish", "0", CVAR_ARCHIVE );
1.1 root 235:
236: if ( !sw_stipplealpha )
237: sw_stipplealpha = Cvar_Get( "sw_stipplealpha", "0", CVAR_ARCHIVE );
238:
239: s_mode_list[SOFTWARE_MENU].curvalue = sw_mode->value;
240: s_mode_list[OPENGL_MENU].curvalue = gl_mode->value;
241:
242: if ( !scr_viewsize )
243: scr_viewsize = Cvar_Get ("viewsize", "100", CVAR_ARCHIVE);
244:
245: s_screensize_slider[SOFTWARE_MENU].curvalue = scr_viewsize->value/10;
246: s_screensize_slider[OPENGL_MENU].curvalue = scr_viewsize->value/10;
247:
248: if ( strcmp( vid_ref->string, "soft" ) == 0 )
249: {
250: s_current_menu_index = SOFTWARE_MENU;
251: s_ref_list[0].curvalue = s_ref_list[1].curvalue = REF_SOFT;
252: }
253: else if ( strcmp( vid_ref->string, "gl" ) == 0 )
254: {
255: s_current_menu_index = OPENGL_MENU;
256: if ( strcmp( gl_driver->string, "3dfxgl" ) == 0 )
257: s_ref_list[s_current_menu_index].curvalue = REF_3DFX;
258: else if ( strcmp( gl_driver->string, "pvrgl" ) == 0 )
259: s_ref_list[s_current_menu_index].curvalue = REF_POWERVR;
260: else if ( strcmp( gl_driver->string, "opengl32" ) == 0 )
261: s_ref_list[s_current_menu_index].curvalue = REF_OPENGL;
262: else
263: // s_ref_list[s_current_menu_index].curvalue = REF_VERITE;
264: s_ref_list[s_current_menu_index].curvalue = REF_OPENGL;
265: }
266:
267: s_software_menu.x = viddef.width * 0.50;
268: s_software_menu.nitems = 0;
269: s_opengl_menu.x = viddef.width * 0.50;
270: s_opengl_menu.nitems = 0;
271:
272: for ( i = 0; i < 2; i++ )
273: {
274: s_ref_list[i].generic.type = MTYPE_SPINCONTROL;
275: s_ref_list[i].generic.name = "driver";
276: s_ref_list[i].generic.x = 0;
277: s_ref_list[i].generic.y = 0;
278: s_ref_list[i].generic.callback = DriverCallback;
279: s_ref_list[i].itemnames = refs;
280:
281: s_mode_list[i].generic.type = MTYPE_SPINCONTROL;
282: s_mode_list[i].generic.name = "video mode";
283: s_mode_list[i].generic.x = 0;
284: s_mode_list[i].generic.y = 10;
285: s_mode_list[i].itemnames = resolutions;
286:
287: s_screensize_slider[i].generic.type = MTYPE_SLIDER;
288: s_screensize_slider[i].generic.x = 0;
289: s_screensize_slider[i].generic.y = 20;
290: s_screensize_slider[i].generic.name = "screen size";
291: s_screensize_slider[i].minvalue = 3;
292: s_screensize_slider[i].maxvalue = 12;
293: s_screensize_slider[i].generic.callback = ScreenSizeCallback;
294:
295: s_brightness_slider[i].generic.type = MTYPE_SLIDER;
296: s_brightness_slider[i].generic.x = 0;
297: s_brightness_slider[i].generic.y = 30;
298: s_brightness_slider[i].generic.name = "brightness";
299: s_brightness_slider[i].generic.callback = BrightnessCallback;
300: s_brightness_slider[i].minvalue = 5;
301: s_brightness_slider[i].maxvalue = 13;
302: s_brightness_slider[i].curvalue = ( 1.3 - vid_gamma->value + 0.5 ) * 10;
303:
304: s_fs_box[i].generic.type = MTYPE_SPINCONTROL;
305: s_fs_box[i].generic.x = 0;
306: s_fs_box[i].generic.y = 40;
307: s_fs_box[i].generic.name = "fullscreen";
308: s_fs_box[i].itemnames = yesno_names;
309: s_fs_box[i].curvalue = vid_fullscreen->value;
310:
311: s_defaults_action[i].generic.type = MTYPE_ACTION;
312: s_defaults_action[i].generic.name = "reset to defaults";
313: s_defaults_action[i].generic.x = 0;
314: s_defaults_action[i].generic.y = 90;
315: s_defaults_action[i].generic.callback = ResetDefaults;
316:
317: s_cancel_action[i].generic.type = MTYPE_ACTION;
318: s_cancel_action[i].generic.name = "cancel";
319: s_cancel_action[i].generic.x = 0;
320: s_cancel_action[i].generic.y = 100;
321: s_cancel_action[i].generic.callback = CancelChanges;
322: }
323:
324: s_stipple_box.generic.type = MTYPE_SPINCONTROL;
325: s_stipple_box.generic.x = 0;
326: s_stipple_box.generic.y = 60;
327: s_stipple_box.generic.name = "stipple alpha";
328: s_stipple_box.curvalue = sw_stipplealpha->value;
329: s_stipple_box.itemnames = yesno_names;
330:
331: s_tq_slider.generic.type = MTYPE_SLIDER;
332: s_tq_slider.generic.x = 0;
333: s_tq_slider.generic.y = 60;
334: s_tq_slider.generic.name = "texture quality";
335: s_tq_slider.minvalue = 0;
336: s_tq_slider.maxvalue = 3;
337: s_tq_slider.curvalue = 3-gl_picmip->value;
338:
339: s_paletted_texture_box.generic.type = MTYPE_SPINCONTROL;
340: s_paletted_texture_box.generic.x = 0;
341: s_paletted_texture_box.generic.y = 70;
342: s_paletted_texture_box.generic.name = "8-bit textures";
343: s_paletted_texture_box.itemnames = yesno_names;
344: s_paletted_texture_box.curvalue = gl_ext_palettedtexture->value;
345:
1.1.1.2 ! root 346: s_finish_box.generic.type = MTYPE_SPINCONTROL;
! 347: s_finish_box.generic.x = 0;
! 348: s_finish_box.generic.y = 80;
! 349: s_finish_box.generic.name = "sync every frame";
! 350: s_finish_box.curvalue = gl_finish->value;
! 351: s_finish_box.itemnames = yesno_names;
! 352:
1.1 root 353: Menu_AddItem( &s_software_menu, ( void * ) &s_ref_list[SOFTWARE_MENU] );
354: Menu_AddItem( &s_software_menu, ( void * ) &s_mode_list[SOFTWARE_MENU] );
355: Menu_AddItem( &s_software_menu, ( void * ) &s_screensize_slider[SOFTWARE_MENU] );
356: Menu_AddItem( &s_software_menu, ( void * ) &s_brightness_slider[SOFTWARE_MENU] );
357: Menu_AddItem( &s_software_menu, ( void * ) &s_fs_box[SOFTWARE_MENU] );
358: Menu_AddItem( &s_software_menu, ( void * ) &s_stipple_box );
359:
360: Menu_AddItem( &s_opengl_menu, ( void * ) &s_ref_list[OPENGL_MENU] );
361: Menu_AddItem( &s_opengl_menu, ( void * ) &s_mode_list[OPENGL_MENU] );
362: Menu_AddItem( &s_opengl_menu, ( void * ) &s_screensize_slider[OPENGL_MENU] );
363: Menu_AddItem( &s_opengl_menu, ( void * ) &s_brightness_slider[OPENGL_MENU] );
364: Menu_AddItem( &s_opengl_menu, ( void * ) &s_fs_box[OPENGL_MENU] );
365: Menu_AddItem( &s_opengl_menu, ( void * ) &s_tq_slider );
366: Menu_AddItem( &s_opengl_menu, ( void * ) &s_paletted_texture_box );
1.1.1.2 ! root 367: Menu_AddItem( &s_opengl_menu, ( void * ) &s_finish_box );
1.1 root 368:
369: Menu_AddItem( &s_software_menu, ( void * ) &s_defaults_action[SOFTWARE_MENU] );
370: Menu_AddItem( &s_software_menu, ( void * ) &s_cancel_action[SOFTWARE_MENU] );
371: Menu_AddItem( &s_opengl_menu, ( void * ) &s_defaults_action[OPENGL_MENU] );
372: Menu_AddItem( &s_opengl_menu, ( void * ) &s_cancel_action[OPENGL_MENU] );
373:
374: Menu_Center( &s_software_menu );
375: Menu_Center( &s_opengl_menu );
376: s_opengl_menu.x -= 8;
377: s_software_menu.x -= 8;
378: }
379:
380: /*
381: ================
382: VID_MenuDraw
383: ================
384: */
385: void VID_MenuDraw (void)
386: {
387: int w, h;
388:
389: if ( s_current_menu_index == 0 )
390: s_current_menu = &s_software_menu;
391: else
392: s_current_menu = &s_opengl_menu;
393:
394: /*
395: ** draw the banner
396: */
397: re.DrawGetPicSize( &w, &h, "m_banner_video" );
398: re.DrawPic( viddef.width / 2 - w / 2, viddef.height /2 - 110, "m_banner_video" );
399:
400: /*
401: ** move cursor to a reasonable starting position
402: */
403: Menu_AdjustCursor( s_current_menu, 1 );
404:
405: /*
406: ** draw the menu
407: */
408: Menu_Draw( s_current_menu );
409: }
410:
411: /*
412: ================
413: VID_MenuKey
414: ================
415: */
416: const char *VID_MenuKey( int key )
417: {
418: menuframework_s *m = s_current_menu;
419: static const char *sound = "misc/menu1.wav";
420:
421: switch ( key )
422: {
423: case K_ESCAPE:
424: ApplyChanges( 0 );
425: return NULL;
426: case K_KP_UPARROW:
427: case K_UPARROW:
428: m->cursor--;
429: Menu_AdjustCursor( m, -1 );
430: break;
431: case K_KP_DOWNARROW:
432: case K_DOWNARROW:
433: m->cursor++;
434: Menu_AdjustCursor( m, 1 );
435: break;
436: case K_KP_LEFTARROW:
437: case K_LEFTARROW:
438: Menu_SlideItem( m, -1 );
439: break;
440: case K_KP_RIGHTARROW:
441: case K_RIGHTARROW:
442: Menu_SlideItem( m, 1 );
443: break;
444: case K_KP_ENTER:
445: case K_ENTER:
446: if ( !Menu_SelectItem( m ) )
447: ApplyChanges( NULL );
448: break;
449: }
450:
451: return sound;
452: }
453:
454:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.