Return to vid_menu.c CVS log

Up to [Quake II] / quake2 / win32

Annotation of quake2/win32/vid_menu.c, revision 1.1

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;
        !            19: 
        !            20: static cvar_t *sw_mode;
        !            21: static cvar_t *sw_stipplealpha;
        !            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 menuaction_s            s_cancel_action[2];
        !            49: static menuaction_s            s_defaults_action[2];
        !            50: 
        !            51: static void DriverCallback( void *unused )
        !            52: {
        !            53:        s_ref_list[!s_current_menu_index].curvalue = s_ref_list[s_current_menu_index].curvalue;
        !            54: 
        !            55:        if ( s_ref_list[s_current_menu_index].curvalue == 0 )
        !            56:        {
        !            57:                s_current_menu = &s_software_menu;
        !            58:                s_current_menu_index = 0;
        !            59:        }
        !            60:        else
        !            61:        {
        !            62:                s_current_menu = &s_opengl_menu;
        !            63:                s_current_menu_index = 1;
        !            64:        }
        !            65: 
        !            66: }
        !            67: 
        !            68: static void ScreenSizeCallback( void *s )
        !            69: {
        !            70:        menuslider_s *slider = ( menuslider_s * ) s;
        !            71: 
        !            72:        Cvar_SetValue( "viewsize", slider->curvalue * 10 );
        !            73: }
        !            74: 
        !            75: static void BrightnessCallback( void *s )
        !            76: {
        !            77:        menuslider_s *slider = ( menuslider_s * ) s;
        !            78: 
        !            79:        if ( s_current_menu_index == SOFTWARE_MENU )
        !            80:                s_brightness_slider[1].curvalue = s_brightness_slider[0].curvalue;
        !            81:        else
        !            82:                s_brightness_slider[0].curvalue = s_brightness_slider[1].curvalue;
        !            83: 
        !            84:        if ( stricmp( vid_ref->string, "soft" ) == 0 )
        !            85:        {
        !            86:                float gamma = ( 0.8 - ( slider->curvalue/10.0 - 0.5 ) ) + 0.5;
        !            87: 
        !            88:                Cvar_SetValue( "vid_gamma", gamma );
        !            89:        }
        !            90: }
        !            91: 
        !            92: static void ResetDefaults( void *unused )
        !            93: {
        !            94:        VID_MenuInit();
        !            95: }
        !            96: 
        !            97: static void ApplyChanges( void *unused )
        !            98: {
        !            99:        float gamma;
        !           100: 
        !           101:        /*
        !           102:        ** make values consistent
        !           103:        */
        !           104:        s_fs_box[!s_current_menu_index].curvalue = s_fs_box[s_current_menu_index].curvalue;
        !           105:        s_brightness_slider[!s_current_menu_index].curvalue = s_brightness_slider[s_current_menu_index].curvalue;
        !           106:        s_ref_list[!s_current_menu_index].curvalue = s_ref_list[s_current_menu_index].curvalue;
        !           107: 
        !           108:        /*
        !           109:        ** invert sense so greater = brighter, and scale to a range of 0.5 to 1.3
        !           110:        */
        !           111:        gamma = ( 0.8 - ( s_brightness_slider[s_current_menu_index].curvalue/10.0 - 0.5 ) ) + 0.5;
        !           112: 
        !           113:        Cvar_SetValue( "vid_gamma", gamma );
        !           114:        Cvar_SetValue( "sw_stipplealpha", s_stipple_box.curvalue );
        !           115:        Cvar_SetValue( "gl_picmip", 3 - s_tq_slider.curvalue );
        !           116:        Cvar_SetValue( "vid_fullscreen", s_fs_box[s_current_menu_index].curvalue );
        !           117:        Cvar_SetValue( "gl_ext_palettedtexture", s_paletted_texture_box.curvalue );
        !           118:        Cvar_SetValue( "sw_mode", s_mode_list[SOFTWARE_MENU].curvalue );
        !           119:        Cvar_SetValue( "gl_mode", s_mode_list[OPENGL_MENU].curvalue );
        !           120: 
        !           121:        switch ( s_ref_list[s_current_menu_index].curvalue )
        !           122:        {
        !           123:        case REF_SOFT:
        !           124:                Cvar_Set( "vid_ref", "soft" );
        !           125:                break;
        !           126:        case REF_OPENGL:
        !           127:                Cvar_Set( "vid_ref", "gl" );
        !           128:                Cvar_Set( "gl_driver", "opengl32" );
        !           129:                break;
        !           130:        case REF_3DFX:
        !           131:                Cvar_Set( "vid_ref", "gl" );
        !           132:                Cvar_Set( "gl_driver", "3dfxgl" );
        !           133:                break;
        !           134:        case REF_POWERVR:
        !           135:                Cvar_Set( "vid_ref", "gl" );
        !           136:                Cvar_Set( "gl_driver", "pvrgl" );
        !           137:                break;
        !           138:        case REF_VERITE:
        !           139:                Cvar_Set( "vid_ref", "gl" );
        !           140:                Cvar_Set( "gl_driver", "veritegl" );
        !           141:                break;
        !           142:        }
        !           143: 
        !           144:        /*
        !           145:        ** update appropriate stuff if we're running OpenGL and gamma
        !           146:        ** has been modified
        !           147:        */
        !           148:        if ( stricmp( vid_ref->string, "gl" ) == 0 )
        !           149:        {
        !           150:                if ( vid_gamma->modified )
        !           151:                {
        !           152:                        vid_ref->modified = true;
        !           153:                        if ( stricmp( gl_driver->string, "3dfxgl" ) == 0 )
        !           154:                        {
        !           155:                                char envbuffer[1024];
        !           156:                                float g;
        !           157: 
        !           158:                                vid_ref->modified = true;
        !           159: 
        !           160:                                g = 2.00 * ( 0.8 - ( vid_gamma->value - 0.5 ) ) + 1.0F;
        !           161:                                Com_sprintf( envbuffer, sizeof(envbuffer), "SSTV2_GAMMA=%f", g );
        !           162:                                putenv( envbuffer );
        !           163:                                Com_sprintf( envbuffer, sizeof(envbuffer), "SST_GAMMA=%f", g );
        !           164:                                putenv( envbuffer );
        !           165: 
        !           166:                                vid_gamma->modified = false;
        !           167:                        }
        !           168:                }
        !           169: 
        !           170:                if ( gl_driver->modified )
        !           171:                        vid_ref->modified = true;
        !           172:        }
        !           173: 
        !           174:        M_ForceMenuOff();
        !           175: }
        !           176: 
        !           177: static void CancelChanges( void *unused )
        !           178: {
        !           179:        extern void M_PopMenu( void );
        !           180: 
        !           181:        M_PopMenu();
        !           182: }
        !           183: 
        !           184: /*
        !           185: ** VID_MenuInit
        !           186: */
        !           187: void VID_MenuInit( void )
        !           188: {
        !           189:        static const char *resolutions[] = 
        !           190:        {
        !           191:                "[320 240  ]",
        !           192:                "[400 300  ]",
        !           193:                "[512 384  ]",
        !           194:                "[640 480  ]",
        !           195:                "[800 600  ]",
        !           196:                "[960 720  ]",
        !           197:                "[1024 768 ]",
        !           198:                "[1152 864 ]",
        !           199:                "[1280 960 ]",
        !           200:                "[1600 1200]",
        !           201:                0
        !           202:        };
        !           203:        static const char *refs[] =
        !           204:        {
        !           205:                "[software      ]",
        !           206:                "[default OpenGL]",
        !           207:                "[3Dfx OpenGL   ]",
        !           208:                "[PowerVR OpenGL]",
        !           209: //             "[Rendition OpenGL]",
        !           210:                0
        !           211:        };
        !           212:        static const char *yesno_names[] =
        !           213:        {
        !           214:                "no",
        !           215:                "yes",
        !           216:                0
        !           217:        };
        !           218:        int i;
        !           219: 
        !           220:        if ( !gl_driver )
        !           221:                gl_driver = Cvar_Get( "gl_driver", "opengl32", 0 );
        !           222:        if ( !gl_picmip )
        !           223:                gl_picmip = Cvar_Get( "gl_picmip", "0", 0 );
        !           224:        if ( !gl_mode )
        !           225:                gl_mode = Cvar_Get( "gl_mode", "3", 0 );
        !           226:        if ( !sw_mode )
        !           227:                sw_mode = Cvar_Get( "sw_mode", "0", 0 );
        !           228:        if ( !gl_ext_palettedtexture )
        !           229:                gl_ext_palettedtexture = Cvar_Get( "gl_ext_palettedtexture", "1", CVAR_ARCHIVE );
        !           230: 
        !           231:        if ( !sw_stipplealpha )
        !           232:                sw_stipplealpha = Cvar_Get( "sw_stipplealpha", "0", CVAR_ARCHIVE );
        !           233: 
        !           234:        s_mode_list[SOFTWARE_MENU].curvalue = sw_mode->value;
        !           235:        s_mode_list[OPENGL_MENU].curvalue = gl_mode->value;
        !           236: 
        !           237:        if ( !scr_viewsize )
        !           238:                scr_viewsize = Cvar_Get ("viewsize", "100", CVAR_ARCHIVE);
        !           239: 
        !           240:        s_screensize_slider[SOFTWARE_MENU].curvalue = scr_viewsize->value/10;
        !           241:        s_screensize_slider[OPENGL_MENU].curvalue = scr_viewsize->value/10;
        !           242: 
        !           243:        if ( strcmp( vid_ref->string, "soft" ) == 0 )
        !           244:        {
        !           245:                s_current_menu_index = SOFTWARE_MENU;
        !           246:                s_ref_list[0].curvalue = s_ref_list[1].curvalue = REF_SOFT;
        !           247:        }
        !           248:        else if ( strcmp( vid_ref->string, "gl" ) == 0 )
        !           249:        {
        !           250:                s_current_menu_index = OPENGL_MENU;
        !           251:                if ( strcmp( gl_driver->string, "3dfxgl" ) == 0 )
        !           252:                        s_ref_list[s_current_menu_index].curvalue = REF_3DFX;
        !           253:                else if ( strcmp( gl_driver->string, "pvrgl" ) == 0 )
        !           254:                        s_ref_list[s_current_menu_index].curvalue = REF_POWERVR;
        !           255:                else if ( strcmp( gl_driver->string, "opengl32" ) == 0 )
        !           256:                        s_ref_list[s_current_menu_index].curvalue = REF_OPENGL;
        !           257:                else
        !           258: //                     s_ref_list[s_current_menu_index].curvalue = REF_VERITE;
        !           259:                        s_ref_list[s_current_menu_index].curvalue = REF_OPENGL;
        !           260:        }
        !           261: 
        !           262:        s_software_menu.x = viddef.width * 0.50;
        !           263:        s_software_menu.nitems = 0;
        !           264:        s_opengl_menu.x = viddef.width * 0.50;
        !           265:        s_opengl_menu.nitems = 0;
        !           266: 
        !           267:        for ( i = 0; i < 2; i++ )
        !           268:        {
        !           269:                s_ref_list[i].generic.type = MTYPE_SPINCONTROL;
        !           270:                s_ref_list[i].generic.name = "driver";
        !           271:                s_ref_list[i].generic.x = 0;
        !           272:                s_ref_list[i].generic.y = 0;
        !           273:                s_ref_list[i].generic.callback = DriverCallback;
        !           274:                s_ref_list[i].itemnames = refs;
        !           275: 
        !           276:                s_mode_list[i].generic.type = MTYPE_SPINCONTROL;
        !           277:                s_mode_list[i].generic.name = "video mode";
        !           278:                s_mode_list[i].generic.x = 0;
        !           279:                s_mode_list[i].generic.y = 10;
        !           280:                s_mode_list[i].itemnames = resolutions;
        !           281: 
        !           282:                s_screensize_slider[i].generic.type     = MTYPE_SLIDER;
        !           283:                s_screensize_slider[i].generic.x                = 0;
        !           284:                s_screensize_slider[i].generic.y                = 20;
        !           285:                s_screensize_slider[i].generic.name     = "screen size";
        !           286:                s_screensize_slider[i].minvalue = 3;
        !           287:                s_screensize_slider[i].maxvalue = 12;
        !           288:                s_screensize_slider[i].generic.callback = ScreenSizeCallback;
        !           289: 
        !           290:                s_brightness_slider[i].generic.type     = MTYPE_SLIDER;
        !           291:                s_brightness_slider[i].generic.x        = 0;
        !           292:                s_brightness_slider[i].generic.y        = 30;
        !           293:                s_brightness_slider[i].generic.name     = "brightness";
        !           294:                s_brightness_slider[i].generic.callback = BrightnessCallback;
        !           295:                s_brightness_slider[i].minvalue = 5;
        !           296:                s_brightness_slider[i].maxvalue = 13;
        !           297:                s_brightness_slider[i].curvalue = ( 1.3 - vid_gamma->value + 0.5 ) * 10;
        !           298: 
        !           299:                s_fs_box[i].generic.type = MTYPE_SPINCONTROL;
        !           300:                s_fs_box[i].generic.x   = 0;
        !           301:                s_fs_box[i].generic.y   = 40;
        !           302:                s_fs_box[i].generic.name        = "fullscreen";
        !           303:                s_fs_box[i].itemnames = yesno_names;
        !           304:                s_fs_box[i].curvalue = vid_fullscreen->value;
        !           305: 
        !           306:                s_defaults_action[i].generic.type = MTYPE_ACTION;
        !           307:                s_defaults_action[i].generic.name = "reset to defaults";
        !           308:                s_defaults_action[i].generic.x    = 0;
        !           309:                s_defaults_action[i].generic.y    = 90;
        !           310:                s_defaults_action[i].generic.callback = ResetDefaults;
        !           311: 
        !           312:                s_cancel_action[i].generic.type = MTYPE_ACTION;
        !           313:                s_cancel_action[i].generic.name = "cancel";
        !           314:                s_cancel_action[i].generic.x    = 0;
        !           315:                s_cancel_action[i].generic.y    = 100;
        !           316:                s_cancel_action[i].generic.callback = CancelChanges;
        !           317:        }
        !           318: 
        !           319:        s_stipple_box.generic.type = MTYPE_SPINCONTROL;
        !           320:        s_stipple_box.generic.x = 0;
        !           321:        s_stipple_box.generic.y = 60;
        !           322:        s_stipple_box.generic.name      = "stipple alpha";
        !           323:        s_stipple_box.curvalue = sw_stipplealpha->value;
        !           324:        s_stipple_box.itemnames = yesno_names;
        !           325: 
        !           326:        s_tq_slider.generic.type        = MTYPE_SLIDER;
        !           327:        s_tq_slider.generic.x           = 0;
        !           328:        s_tq_slider.generic.y           = 60;
        !           329:        s_tq_slider.generic.name        = "texture quality";
        !           330:        s_tq_slider.minvalue = 0;
        !           331:        s_tq_slider.maxvalue = 3;
        !           332:        s_tq_slider.curvalue = 3-gl_picmip->value;
        !           333: 
        !           334:        s_paletted_texture_box.generic.type = MTYPE_SPINCONTROL;
        !           335:        s_paletted_texture_box.generic.x        = 0;
        !           336:        s_paletted_texture_box.generic.y        = 70;
        !           337:        s_paletted_texture_box.generic.name     = "8-bit textures";
        !           338:        s_paletted_texture_box.itemnames = yesno_names;
        !           339:        s_paletted_texture_box.curvalue = gl_ext_palettedtexture->value;
        !           340: 
        !           341:        Menu_AddItem( &s_software_menu, ( void * ) &s_ref_list[SOFTWARE_MENU] );
        !           342:        Menu_AddItem( &s_software_menu, ( void * ) &s_mode_list[SOFTWARE_MENU] );
        !           343:        Menu_AddItem( &s_software_menu, ( void * ) &s_screensize_slider[SOFTWARE_MENU] );
        !           344:        Menu_AddItem( &s_software_menu, ( void * ) &s_brightness_slider[SOFTWARE_MENU] );
        !           345:        Menu_AddItem( &s_software_menu, ( void * ) &s_fs_box[SOFTWARE_MENU] );
        !           346:        Menu_AddItem( &s_software_menu, ( void * ) &s_stipple_box );
        !           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_cancel_action[SOFTWARE_MENU] );
        !           358:        Menu_AddItem( &s_opengl_menu, ( void * ) &s_defaults_action[OPENGL_MENU] );
        !           359:        Menu_AddItem( &s_opengl_menu, ( void * ) &s_cancel_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:        menuframework_s *m = s_current_menu;
        !           406:        static const char *sound = "misc/menu1.wav";
        !           407: 
        !           408:        switch ( key )
        !           409:        {
        !           410:        case K_ESCAPE:
        !           411:                ApplyChanges( 0 );
        !           412:                return NULL;
        !           413:        case K_KP_UPARROW:
        !           414:        case K_UPARROW:
        !           415:                m->cursor--;
        !           416:                Menu_AdjustCursor( m, -1 );
        !           417:                break;
        !           418:        case K_KP_DOWNARROW:
        !           419:        case K_DOWNARROW:
        !           420:                m->cursor++;
        !           421:                Menu_AdjustCursor( m, 1 );
        !           422:                break;
        !           423:        case K_KP_LEFTARROW:
        !           424:        case K_LEFTARROW:
        !           425:                Menu_SlideItem( m, -1 );
        !           426:                break;
        !           427:        case K_KP_RIGHTARROW:
        !           428:        case K_RIGHTARROW:
        !           429:                Menu_SlideItem( m, 1 );
        !           430:                break;
        !           431:        case K_KP_ENTER:
        !           432:        case K_ENTER:
        !           433:                if ( !Menu_SelectItem( m ) )
        !           434:                        ApplyChanges( NULL );
        !           435:                break;
        !           436:        }
        !           437: 
        !           438:        return sound;
        !           439: }
        !           440: 
        !           441: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.