vid.h File Reference

Go to the source code of this file.

Classes
struct	vrect_s
struct	viddef_t

Typedefs
typedef struct vrect_s	vrect_t

Functions
void	VID_Init (void)
void	VID_Shutdown (void)
void	VID_CheckChanges (void)
void	VID_MenuInit (void)
void	VID_MenuDraw (void)
const char *	VID_MenuKey (int)

Variables
viddef_t	viddef

Typedef Documentation

vrect_t

typedef struct vrect_s vrect_t

Function Documentation

VID_CheckChanges()

void VID_CheckChanges

(

void

)

Definition at line 641 of file vid_dll.c.

{
    char name[100];
 
    if ( win_noalttab->modified )
    {
        if ( win_noalttab->value )
        {
            WIN_DisableAltTab();
        }
        else
        {
            WIN_EnableAltTab();
        }
        win_noalttab->modified = false;
    }
 
    if ( vid_ref->modified )
    {
        cl.force_refdef = true;     // can't use a paused refdef
        S_StopAllSounds();
    }
    while (vid_ref->modified)
    {
        /*
        ** refresh has changed
        */
        vid_ref->modified = false;
        vid_fullscreen->modified = true;
        cl.refresh_prepped = false;
        cls.disable_screen = true;
 
        Com_sprintf( name, sizeof(name), "ref_%s.dll", vid_ref->string );
        if ( !VID_LoadRefresh( name ) )
        {
            if ( strcmp (vid_ref->string, "soft") == 0 )
                Com_Error (ERR_FATAL, "Couldn't fall back to software refresh!");
            Cvar_Set( "vid_ref", "soft" );
 
            /*
            ** drop the console if we fail to load a refresh
            */
            if ( cls.key_dest != key_console )
            {
                Con_ToggleConsole_f();
            }
        }
        cls.disable_screen = false;
    }
 
    /*
    ** update our window position
    */
    if ( vid_xpos->modified || vid_ypos->modified )
    {
        if (!vid_fullscreen->value)
            VID_UpdateWindowPosAndSize( vid_xpos->value, vid_ypos->value );
 
        vid_xpos->modified = false;
        vid_ypos->modified = false;
    }
}

Referenced by CL_Frame(), and VID_Init().

VID_Init()

void VID_Init

(

void

)

Definition at line 709 of file vid_dll.c.

{
    /* Create the video variables so we know how to start the graphics drivers */
    vid_ref = Cvar_Get ("vid_ref", "soft", CVAR_ARCHIVE);
    vid_xpos = Cvar_Get ("vid_xpos", "3", CVAR_ARCHIVE);
    vid_ypos = Cvar_Get ("vid_ypos", "22", CVAR_ARCHIVE);
    vid_fullscreen = Cvar_Get ("vid_fullscreen", "0", CVAR_ARCHIVE);
    vid_gamma = Cvar_Get( "vid_gamma", "1", CVAR_ARCHIVE );
    win_noalttab = Cvar_Get( "win_noalttab", "0", CVAR_ARCHIVE );
 
    /* Add some console commands that we want to handle */
    Cmd_AddCommand ("vid_restart", VID_Restart_f);
    Cmd_AddCommand ("vid_front", VID_Front_f);
 
    /*
    ** this is a gross hack but necessary to clamp the mode for 3Dfx
    */
#if 0
    {
        cvar_t *gl_driver = Cvar_Get( "gl_driver", "opengl32", 0 );
        cvar_t *gl_mode = Cvar_Get( "gl_mode", "3", 0 );
 
        if ( stricmp( gl_driver->string, "3dfxgl" ) == 0 )
        {
            Cvar_SetValue( "gl_mode", 3 );
            viddef.width  = 640;
            viddef.height = 480;
        }
    }
#endif
 
    /* Disable the 3Dfx splash screen */
    putenv("FX_GLIDE_NO_SPLASH=0");
        
    /* Start the graphics mode and load refresh DLL */
    VID_CheckChanges();
}

Referenced by CL_Init().

VID_MenuDraw()

void VID_MenuDraw

(

void

)

Definition at line 405 of file vid_menu.c.

{
    int w, h;
 
    if ( s_current_menu_index == 0 )
        s_current_menu = &s_software_menu;
    else
        s_current_menu = &s_opengl_menu;
 
    /*
    ** draw the banner
    */
    re.DrawGetPicSize( &w, &h, "m_banner_video" );
    re.DrawPic( viddef.width / 2 - w / 2, viddef.height /2 - 110, "m_banner_video" );
 
    /*
    ** move cursor to a reasonable starting position
    */
    Menu_AdjustCursor( s_current_menu, 1 );
 
    /*
    ** draw the menu
    */
    Menu_Draw( s_current_menu );
}

Referenced by M_Menu_Video_f().

VID_MenuInit()

void VID_MenuInit

(

void

)

Definition at line 209 of file vid_menu.c.

{
    static const char *resolutions[] = 
    {
        "[320 240  ]",
        "[400 300  ]",
        "[512 384  ]",
        "[640 480  ]",
        "[800 600  ]",
        "[960 720  ]",
        "[1024 768 ]",
        "[1152 864 ]",
        "[1280 960 ]",
        "[1600 1200]",
        "[2048 1536]",
        0
    };
    static const char *refs[] =
    {
        "[software      ]",
        "[default OpenGL]",
        "[3Dfx OpenGL   ]",
        "[PowerVR OpenGL]",
//      "[Rendition OpenGL]",
        0
    };
    static const char *yesno_names[] =
    {
        "no",
        "yes",
        0
    };
    int i;
 
    if ( !gl_driver )
        gl_driver = Cvar_Get( "gl_driver", "opengl32", 0 );
    if ( !gl_picmip )
        gl_picmip = Cvar_Get( "gl_picmip", "0", 0 );
    if ( !gl_mode )
        gl_mode = Cvar_Get( "gl_mode", "3", 0 );
    if ( !sw_mode )
        sw_mode = Cvar_Get( "sw_mode", "0", 0 );
    if ( !gl_ext_palettedtexture )
        gl_ext_palettedtexture = Cvar_Get( "gl_ext_palettedtexture", "1", CVAR_ARCHIVE );
    if ( !gl_finish )
        gl_finish = Cvar_Get( "gl_finish", "0", CVAR_ARCHIVE );
 
    if ( !sw_stipplealpha )
        sw_stipplealpha = Cvar_Get( "sw_stipplealpha", "0", CVAR_ARCHIVE );
 
    s_mode_list[SOFTWARE_MENU].curvalue = sw_mode->value;
    s_mode_list[OPENGL_MENU].curvalue = gl_mode->value;
 
    if ( !scr_viewsize )
        scr_viewsize = Cvar_Get ("viewsize", "100", CVAR_ARCHIVE);
 
    s_screensize_slider[SOFTWARE_MENU].curvalue = scr_viewsize->value/10;
    s_screensize_slider[OPENGL_MENU].curvalue = scr_viewsize->value/10;
 
    if ( strcmp( vid_ref->string, "soft" ) == 0 )
    {
        s_current_menu_index = SOFTWARE_MENU;
        s_ref_list[0].curvalue = s_ref_list[1].curvalue = REF_SOFT;
    }
    else if ( strcmp( vid_ref->string, "gl" ) == 0 )
    {
        s_current_menu_index = OPENGL_MENU;
        if ( strcmp( gl_driver->string, "3dfxgl" ) == 0 )
            s_ref_list[s_current_menu_index].curvalue = REF_3DFX;
        else if ( strcmp( gl_driver->string, "pvrgl" ) == 0 )
            s_ref_list[s_current_menu_index].curvalue = REF_POWERVR;
        else if ( strcmp( gl_driver->string, "opengl32" ) == 0 )
            s_ref_list[s_current_menu_index].curvalue = REF_OPENGL;
        else
//          s_ref_list[s_current_menu_index].curvalue = REF_VERITE;
            s_ref_list[s_current_menu_index].curvalue = REF_OPENGL;
    }
 
    s_software_menu.x = viddef.width * 0.50;
    s_software_menu.nitems = 0;
    s_opengl_menu.x = viddef.width * 0.50;
    s_opengl_menu.nitems = 0;
 
    for ( i = 0; i < 2; i++ )
    {
        s_ref_list[i].generic.type = MTYPE_SPINCONTROL;
        s_ref_list[i].generic.name = "driver";
        s_ref_list[i].generic.x = 0;
        s_ref_list[i].generic.y = 0;
        s_ref_list[i].generic.callback = DriverCallback;
        s_ref_list[i].itemnames = refs;
 
        s_mode_list[i].generic.type = MTYPE_SPINCONTROL;
        s_mode_list[i].generic.name = "video mode";
        s_mode_list[i].generic.x = 0;
        s_mode_list[i].generic.y = 10;
        s_mode_list[i].itemnames = resolutions;
 
        s_screensize_slider[i].generic.type = MTYPE_SLIDER;
        s_screensize_slider[i].generic.x        = 0;
        s_screensize_slider[i].generic.y        = 20;
        s_screensize_slider[i].generic.name = "screen size";
        s_screensize_slider[i].minvalue = 3;
        s_screensize_slider[i].maxvalue = 12;
        s_screensize_slider[i].generic.callback = ScreenSizeCallback;
 
        s_brightness_slider[i].generic.type = MTYPE_SLIDER;
        s_brightness_slider[i].generic.x    = 0;
        s_brightness_slider[i].generic.y    = 30;
        s_brightness_slider[i].generic.name = "brightness";
        s_brightness_slider[i].generic.callback = BrightnessCallback;
        s_brightness_slider[i].minvalue = 5;
        s_brightness_slider[i].maxvalue = 13;
        s_brightness_slider[i].curvalue = ( 1.3 - vid_gamma->value + 0.5 ) * 10;
 
        s_fs_box[i].generic.type = MTYPE_SPINCONTROL;
        s_fs_box[i].generic.x   = 0;
        s_fs_box[i].generic.y   = 40;
        s_fs_box[i].generic.name    = "fullscreen";
        s_fs_box[i].itemnames = yesno_names;
        s_fs_box[i].curvalue = vid_fullscreen->value;
 
        s_defaults_action[i].generic.type = MTYPE_ACTION;
        s_defaults_action[i].generic.name = "reset to defaults";
        s_defaults_action[i].generic.x    = 0;
        s_defaults_action[i].generic.y    = 90;
        s_defaults_action[i].generic.callback = ResetDefaults;
 
        s_cancel_action[i].generic.type = MTYPE_ACTION;
        s_cancel_action[i].generic.name = "cancel";
        s_cancel_action[i].generic.x    = 0;
        s_cancel_action[i].generic.y    = 100;
        s_cancel_action[i].generic.callback = CancelChanges;
    }
 
    s_stipple_box.generic.type = MTYPE_SPINCONTROL;
    s_stipple_box.generic.x = 0;
    s_stipple_box.generic.y = 60;
    s_stipple_box.generic.name  = "stipple alpha";
    s_stipple_box.curvalue = sw_stipplealpha->value;
    s_stipple_box.itemnames = yesno_names;
 
    s_tq_slider.generic.type    = MTYPE_SLIDER;
    s_tq_slider.generic.x       = 0;
    s_tq_slider.generic.y       = 60;
    s_tq_slider.generic.name    = "texture quality";
    s_tq_slider.minvalue = 0;
    s_tq_slider.maxvalue = 3;
    s_tq_slider.curvalue = 3-gl_picmip->value;
 
    s_paletted_texture_box.generic.type = MTYPE_SPINCONTROL;
    s_paletted_texture_box.generic.x    = 0;
    s_paletted_texture_box.generic.y    = 70;
    s_paletted_texture_box.generic.name = "8-bit textures";
    s_paletted_texture_box.itemnames = yesno_names;
    s_paletted_texture_box.curvalue = gl_ext_palettedtexture->value;
 
    s_finish_box.generic.type = MTYPE_SPINCONTROL;
    s_finish_box.generic.x  = 0;
    s_finish_box.generic.y  = 80;
    s_finish_box.generic.name   = "sync every frame";
    s_finish_box.curvalue = gl_finish->value;
    s_finish_box.itemnames = yesno_names;
 
    Menu_AddItem( &s_software_menu, ( void * ) &s_ref_list[SOFTWARE_MENU] );
    Menu_AddItem( &s_software_menu, ( void * ) &s_mode_list[SOFTWARE_MENU] );
    Menu_AddItem( &s_software_menu, ( void * ) &s_screensize_slider[SOFTWARE_MENU] );
    Menu_AddItem( &s_software_menu, ( void * ) &s_brightness_slider[SOFTWARE_MENU] );
    Menu_AddItem( &s_software_menu, ( void * ) &s_fs_box[SOFTWARE_MENU] );
    Menu_AddItem( &s_software_menu, ( void * ) &s_stipple_box );
 
    Menu_AddItem( &s_opengl_menu, ( void * ) &s_ref_list[OPENGL_MENU] );
    Menu_AddItem( &s_opengl_menu, ( void * ) &s_mode_list[OPENGL_MENU] );
    Menu_AddItem( &s_opengl_menu, ( void * ) &s_screensize_slider[OPENGL_MENU] );
    Menu_AddItem( &s_opengl_menu, ( void * ) &s_brightness_slider[OPENGL_MENU] );
    Menu_AddItem( &s_opengl_menu, ( void * ) &s_fs_box[OPENGL_MENU] );
    Menu_AddItem( &s_opengl_menu, ( void * ) &s_tq_slider );
    Menu_AddItem( &s_opengl_menu, ( void * ) &s_paletted_texture_box );
    Menu_AddItem( &s_opengl_menu, ( void * ) &s_finish_box );
 
    Menu_AddItem( &s_software_menu, ( void * ) &s_defaults_action[SOFTWARE_MENU] );
    Menu_AddItem( &s_software_menu, ( void * ) &s_cancel_action[SOFTWARE_MENU] );
    Menu_AddItem( &s_opengl_menu, ( void * ) &s_defaults_action[OPENGL_MENU] );
    Menu_AddItem( &s_opengl_menu, ( void * ) &s_cancel_action[OPENGL_MENU] );
 
    Menu_Center( &s_software_menu );
    Menu_Center( &s_opengl_menu );
    s_opengl_menu.x -= 8;
    s_software_menu.x -= 8;
}

Referenced by M_Menu_Video_f(), ResetDefaults(), and VID_LoadRefresh().

VID_MenuKey()

const char* VID_MenuKey

(

int

)

Definition at line 436 of file vid_menu.c.

{
    menuframework_s *m = s_current_menu;
    static const char *sound = "misc/menu1.wav";
 
    switch ( key )
    {
    case K_ESCAPE:
        ApplyChanges( 0 );
        return NULL;
    case K_KP_UPARROW:
    case K_UPARROW:
        m->cursor--;
        Menu_AdjustCursor( m, -1 );
        break;
    case K_KP_DOWNARROW:
    case K_DOWNARROW:
        m->cursor++;
        Menu_AdjustCursor( m, 1 );
        break;
    case K_KP_LEFTARROW:
    case K_LEFTARROW:
        Menu_SlideItem( m, -1 );
        break;
    case K_KP_RIGHTARROW:
    case K_RIGHTARROW:
        Menu_SlideItem( m, 1 );
        break;
    case K_KP_ENTER:
    case K_ENTER:
        if ( !Menu_SelectItem( m ) )
            ApplyChanges( NULL );
        break;
    }
 
    return sound;
}

Referenced by M_Menu_Video_f().

VID_Shutdown()

void VID_Shutdown

(

void

)

Definition at line 752 of file vid_dll.c.

{
    if ( reflib_active )
    {
        re.Shutdown ();
        VID_FreeReflib ();
    }
}

Referenced by CL_Shutdown().

Variable Documentation

viddef

viddef_t viddef

Definition at line 49 of file vid_dll.c.

Referenced by AddressBook_MenuInit(), CL_DrawInventory(), CL_PrepRefresh(), Con_CheckResize(), Con_DrawConsole(), Con_DrawNotify(), DMOptions_MenuInit(), DownloadOptions_MenuInit(), Game_MenuInit(), JoinServer_MenuInit(), Keys_MenuInit(), LoadGame_MenuInit(), M_Banner(), M_Credits_MenuDraw(), M_Draw(), M_DrawCharacter(), M_DrawPic(), M_Main_Draw(), M_Quit_Draw(), Multiplayer_MenuInit(), Options_MenuInit(), PlayerConfig_MenuDraw(), PlayerConfig_MenuInit(), SaveGame_MenuInit(), SCR_CalcVrect(), SCR_DirtyScreen(), SCR_DrawCenterString(), SCR_DrawCinematic(), SCR_DrawConsole(), SCR_DrawCrosshair(), SCR_DrawLoading(), SCR_DrawPause(), SCR_ExecuteLayoutString(), SCR_TileClear(), SCR_UpdateScreen(), StartServer_MenuInit(), VID_Init(), VID_MenuDraw(), VID_MenuInit(), VID_NewWindow(), and VID_UpdateWindowPosAndSize().