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