static void M_ModList_Draw (void);
-static void M_Main_Key (int key, char ascii);
- static void M_SinglePlayer_Key (int key, char ascii);
- static void M_Transfusion_Episode_Key (int key, char ascii);
- static void M_Transfusion_Skill_Key (int key, char ascii);
- static void M_Load_Key (int key, char ascii);
- static void M_Save_Key (int key, char ascii);
- static void M_MultiPlayer_Key (int key, char ascii);
- static void M_Setup_Key (int key, char ascii);
- static void M_Options_Key (int key, char ascii);
- static void M_Options_Effects_Key (int key, char ascii);
- static void M_Options_Graphics_Key (int key, char ascii);
- static void M_Options_ColorControl_Key (int key, char ascii);
- static void M_Keys_Key (int key, char ascii);
- static void M_Reset_Key (int key, char ascii);
- static void M_Video_Key (int key, char ascii);
- static void M_Help_Key (int key, char ascii);
- static void M_Credits_Key (int key, char ascii);
- static void M_Quit_Key (int key, char ascii);
-static void M_LanConfig_Key (int key, char ascii);
-static void M_GameOptions_Key (int key, char ascii);
-static void M_ServerList_Key (int key, char ascii);
-static void M_ModList_Key (int key, char ascii);
-
-static qboolean m_entersound; // play after drawing a frame, so caching won't disrupt the sound
+static void M_Main_Key (int key, int ascii);
+ static void M_SinglePlayer_Key (int key, int ascii);
+ static void M_Transfusion_Episode_Key (int key, int ascii);
+ static void M_Transfusion_Skill_Key (int key, int ascii);
+ static void M_Load_Key (int key, int ascii);
+ static void M_Save_Key (int key, int ascii);
+ static void M_MultiPlayer_Key (int key, int ascii);
+ static void M_Setup_Key (int key, int ascii);
+ static void M_Options_Key (int key, int ascii);
+ static void M_Options_Effects_Key (int key, int ascii);
+ static void M_Options_Graphics_Key (int key, int ascii);
+ static void M_Options_ColorControl_Key (int key, int ascii);
+ static void M_Keys_Key (int key, int ascii);
+ static void M_Reset_Key (int key, int ascii);
+ static void M_Video_Key (int key, int ascii);
+ static void M_Help_Key (int key, int ascii);
+ static void M_Credits_Key (int key, int ascii);
+ static void M_Quit_Key (int key, int ascii);
+static void M_LanConfig_Key (int key, int ascii);
+static void M_GameOptions_Key (int key, int ascii);
+static void M_ServerList_Key (int key, int ascii);
+static void M_ModList_Key (int key, int ascii);
+
+static qboolean m_entersound; ///< play after drawing a frame, so caching won't disrupt the sound
void M_Update_Return_Reason(char *s)
{
strlcpy(m_return_reason, s, sizeof(m_return_reason));
if (s)
- Con_Printf("%s\n", s);
+ Con_DPrintf("%s\n", s);
}
#define StartingGame (m_multiplayer_cursor == 1)
char temp[2];
temp[0] = num;
temp[1] = 0;
- DrawQ_String_Font(menu_x + cx, menu_y + cy, temp, 1, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_MENU);
+ DrawQ_String(menu_x + cx, menu_y + cy, temp, 1, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_MENU);
}
static void M_PrintColored(float cx, float cy, const char *str)
{
- DrawQ_String_Font(menu_x + cx, menu_y + cy, str, 0, 8, 8, 1, 1, 1, 1, 0, NULL, false, FONT_MENU);
+ DrawQ_String(menu_x + cx, menu_y + cy, str, 0, 8, 8, 1, 1, 1, 1, 0, NULL, false, FONT_MENU);
}
static void M_Print(float cx, float cy, const char *str)
{
- DrawQ_String_Font(menu_x + cx, menu_y + cy, str, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_MENU);
+ DrawQ_String(menu_x + cx, menu_y + cy, str, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_MENU);
}
static void M_PrintRed(float cx, float cy, const char *str)
{
- DrawQ_String_Font(menu_x + cx, menu_y + cy, str, 0, 8, 8, 1, 0, 0, 1, 0, NULL, true, FONT_MENU);
+ DrawQ_String(menu_x + cx, menu_y + cy, str, 0, 8, 8, 1, 0, 0, 1, 0, NULL, true, FONT_MENU);
}
static void M_ItemPrint(float cx, float cy, const char *str, int unghosted)
{
if (unghosted)
- DrawQ_String_Font(menu_x + cx, menu_y + cy, str, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_MENU);
+ DrawQ_String(menu_x + cx, menu_y + cy, str, 0, 8, 8, 1, 1, 1, 1, 0, NULL, true, FONT_MENU);
else
- DrawQ_String_Font(menu_x + cx, menu_y + cy, str, 0, 8, 8, 0.4, 0.4, 0.4, 1, 0, NULL, true, FONT_MENU);
+ DrawQ_String(menu_x + cx, menu_y + cy, str, 0, 8, 8, 0.4, 0.4, 0.4, 1, 0, NULL, true, FONT_MENU);
}
static void M_DrawPic(float cx, float cy, const char *picname)
{
- DrawQ_Pic(menu_x + cx, menu_y + cy, Draw_CachePic(picname, true), 0, 0, 1, 1, 1, 1, 0);
+ DrawQ_Pic(menu_x + cx, menu_y + cy, Draw_CachePic (picname), 0, 0, 1, 1, 1, 1, 0);
}
static void M_DrawTextBox(float x, float y, float width, float height)
{
m_entersound = true;
- if (key_dest != key_menu || m_state != m_main)
+ if ((key_dest != key_menu && key_dest != key_menu_grabbed) || m_state != m_main)
{
if(Cmd_Argc() == 2 && !strcmp(Cmd_Argv(1), "1"))
return;
}
-static void M_Demo_Key (int k, char ascii)
+static void M_Demo_Key (int k, int ascii)
{
switch (k)
{
MAIN_ITEMS = 5;
// check if the game data is missing and use a different main menu if so
- m_missingdata = !forceqmenu.integer && Draw_CachePic (s, true)->tex == r_texture_notexture;
+ m_missingdata = !forceqmenu.integer && Draw_CachePic (s)->tex == r_texture_notexture;
if (m_missingdata)
MAIN_ITEMS = 2;
if (gamemode == GAME_TRANSFUSION) {
int y1, y2, y3;
M_Background(640, 480);
- p = Draw_CachePic ("gfx/menu/tb-transfusion", true);
+ p = Draw_CachePic ("gfx/menu/tb-transfusion");
M_DrawPic (640/2 - p->width/2, 40, "gfx/menu/tb-transfusion");
y2 = 120;
// 8 rather than MAIN_ITEMS to skip a number and not miss the last option
M_Background(320, 200);
M_DrawPic (16, 4, "gfx/qplaque");
- p = Draw_CachePic ("gfx/ttl_main", true);
+ p = Draw_CachePic ("gfx/ttl_main");
M_DrawPic ( (320-p->width)/2, 4, "gfx/ttl_main");
// Nehahra
if (gamemode == GAME_NEHAHRA)
}
-static void M_Main_Key (int key, char ascii)
+static void M_Main_Key (int key, int ascii)
{
switch (key)
{
M_Background(320, 200);
M_DrawPic (16, 4, "gfx/qplaque");
- p = Draw_CachePic ("gfx/ttl_sgl", true);
+ p = Draw_CachePic ("gfx/ttl_sgl");
// Some mods don't have a single player mode
if (gamemode == GAME_GOODVSBAD2 || gamemode == GAME_BATTLEMECH)
}
-static void M_SinglePlayer_Key (int key, char ascii)
+static void M_SinglePlayer_Key (int key, int ascii)
{
if (gamemode == GAME_GOODVSBAD2 || gamemode == GAME_BATTLEMECH)
{
//=============================================================================
/* LOAD/SAVE MENU */
-static int load_cursor; // 0 < load_cursor < MAX_SAVEGAMES
+static int load_cursor; ///< 0 < load_cursor < MAX_SAVEGAMES
-#define MAX_SAVEGAMES 12
static char m_filenames[MAX_SAVEGAMES][SAVEGAME_COMMENT_LENGTH+1];
static int loadable[MAX_SAVEGAMES];
{
strlcpy (m_filenames[i], "--- UNUSED SLOT ---", sizeof(m_filenames[i]));
loadable[i] = false;
- sprintf (name, "s%i.sav", (int)i);
- f = FS_Open (name, "rb", false, false);
+ dpsnprintf (name, sizeof(name), "s%i.sav", (int)i);
+ f = FS_OpenRealFile (name, "rb", false);
if (!f)
continue;
// read enough to get the comment
M_Background(320, 200);
- p = Draw_CachePic ("gfx/p_load", true);
+ p = Draw_CachePic ("gfx/p_load");
M_DrawPic ( (320-p->width)/2, 4, "gfx/p_load" );
for (i=0 ; i< MAX_SAVEGAMES; i++)
M_Background(320, 200);
- p = Draw_CachePic ("gfx/p_save", true);
+ p = Draw_CachePic ("gfx/p_save");
M_DrawPic ( (320-p->width)/2, 4, "gfx/p_save");
for (i=0 ; i<MAX_SAVEGAMES ; i++)
}
-static void M_Load_Key (int k, char ascii)
+static void M_Load_Key (int k, int ascii)
{
switch (k)
{
}
-static void M_Save_Key (int k, char ascii)
+static void M_Save_Key (int k, int ascii)
{
switch (k)
{
cachepic_t *p;
M_Background(640, 480);
- p = Draw_CachePic ("gfx/menu/tb-episodes", true);
+ p = Draw_CachePic ("gfx/menu/tb-episodes");
M_DrawPic (640/2 - p->width/2, 40, "gfx/menu/tb-episodes");
for (y = 0; y < EPISODE_ITEMS; y++){
M_DrawPic (0, 160 + y * 40, va("gfx/menu/episode%i", y+1));
M_DrawPic (0, 120 + (m_episode_cursor + 1) * 40, va("gfx/menu/episode%iselected", m_episode_cursor + 1));
}
-static void M_Transfusion_Episode_Key (int key, char ascii)
+static void M_Transfusion_Episode_Key (int key, int ascii)
{
switch (key)
{
cachepic_t *p;
M_Background(640, 480);
- p = Draw_CachePic ("gfx/menu/tb-difficulty", true);
+ p = Draw_CachePic ("gfx/menu/tb-difficulty");
M_DrawPic(640/2 - p->width/2, 40, "gfx/menu/tb-difficulty");
for (y = 0; y < SKILL_ITEMS; y++)
M_DrawPic (0, 140 + (m_skill_cursor + 1) *40, va("gfx/menu/difficulty%iselected", m_skill_cursor + 1));
}
-static void M_Transfusion_Skill_Key (int key, char ascii)
+static void M_Transfusion_Skill_Key (int key, int ascii)
{
switch (key)
{
if (gamemode == GAME_TRANSFUSION)
{
M_Background(640, 480);
- p = Draw_CachePic ("gfx/menu/tb-online", true);
+ p = Draw_CachePic ("gfx/menu/tb-online");
M_DrawPic (640/2 - p->width/2, 140, "gfx/menu/tb-online");
for (f = 1; f <= MULTIPLAYER_ITEMS; f++)
M_DrawPic (0, 180 + f*40, va("gfx/menu/online%i", f));
M_Background(320, 200);
M_DrawPic (16, 4, "gfx/qplaque");
- p = Draw_CachePic ("gfx/p_multi", true);
+ p = Draw_CachePic ("gfx/p_multi");
M_DrawPic ( (320-p->width)/2, 4, "gfx/p_multi");
M_DrawPic (72, 32, "gfx/mp_menu");
}
-static void M_MultiPlayer_Key (int key, char ascii)
+static void M_MultiPlayer_Key (int key, int ascii)
{
switch (key)
{
M_Background(320, 200);
M_DrawPic (16, 4, "gfx/qplaque");
- p = Draw_CachePic ("gfx/p_multi", true);
+ p = Draw_CachePic ("gfx/p_multi");
M_DrawPic ( (320-p->width)/2, 4, "gfx/p_multi");
M_Print(64, 40, "Your name");
}
-static void M_Setup_Key (int k, char ascii)
+static void M_Setup_Key (int k, int ascii)
{
int l;
M_DrawCharacter (x+i*8, y, 130);
M_DrawCharacter (x + (SLIDER_RANGE-1)*8 * range, y, 131);
if (fabs((int)num - num) < 0.01)
- sprintf(text, "%i", (int)num);
+ dpsnprintf(text, sizeof(text), "%i", (int)num);
else
- sprintf(text, "%.3f", num);
+ dpsnprintf(text, sizeof(text), "%.3f", num);
M_Print(x + (SLIDER_RANGE+2) * 8, y, text);
}
else if (options_cursor == optnum++) ;
else if (options_cursor == optnum++) ;
else if (options_cursor == optnum++) ;
- else if (options_cursor == optnum++) Cvar_SetValueQuick(&crosshair, bound(0, crosshair.integer + dir, 6));
+ else if (options_cursor == optnum++) Cvar_SetValueQuick(&crosshair, bound(0, crosshair.integer + dir, 7));
else if (options_cursor == optnum++) Cvar_SetValueQuick(&sensitivity, bound(1, sensitivity.value + dir * 0.5, 50));
else if (options_cursor == optnum++) Cvar_SetValueQuick(&m_pitch, -m_pitch.value);
else if (options_cursor == optnum++) Cvar_SetValueQuick(&scr_fov, bound(1, scr_fov.integer + dir * 1, 170));
M_Background(320, bound(200, 32 + OPTIONS_ITEMS * 8, vid_conheight.integer));
M_DrawPic(16, 4, "gfx/qplaque");
- p = Draw_CachePic("gfx/p_option", true);
+ p = Draw_CachePic ("gfx/p_option");
M_DrawPic((320-p->width)/2, 4, "gfx/p_option");
optnum = 0;
M_Options_PrintCommand( " Go to console", true);
M_Options_PrintCommand( " Reset to defaults", true);
M_Options_PrintCommand( " Change Video Mode", true);
- M_Options_PrintSlider( " Crosshair", true, crosshair.value, 0, 5);
+ M_Options_PrintSlider( " Crosshair", true, crosshair.value, 0, 7);
M_Options_PrintSlider( " Mouse Speed", true, sensitivity.value, 1, 50);
M_Options_PrintCheckbox(" Invert Mouse", true, m_pitch.value < 0);
M_Options_PrintSlider( " Field of View", true, scr_fov.integer, 1, 170);
}
-static void M_Options_Key (int k, char ascii)
+static void M_Options_Key (int k, int ascii)
{
switch (k)
{
M_Background(320, bound(200, 32 + OPTIONS_EFFECTS_ITEMS * 8, vid_conheight.integer));
M_DrawPic(16, 4, "gfx/qplaque");
- p = Draw_CachePic("gfx/p_option", true);
+ p = Draw_CachePic ("gfx/p_option");
M_DrawPic((320-p->width)/2, 4, "gfx/p_option");
optcursor = options_effects_cursor;
}
-static void M_Options_Effects_Key (int k, char ascii)
+static void M_Options_Effects_Key (int k, int ascii)
{
switch (k)
{
M_Background(320, bound(200, 32 + OPTIONS_GRAPHICS_ITEMS * 8, vid_conheight.integer));
M_DrawPic(16, 4, "gfx/qplaque");
- p = Draw_CachePic("gfx/p_option", true);
+ p = Draw_CachePic ("gfx/p_option");
M_DrawPic((320-p->width)/2, 4, "gfx/p_option");
optcursor = options_graphics_cursor;
}
-static void M_Options_Graphics_Key (int k, char ascii)
+static void M_Options_Graphics_Key (int k, int ascii)
{
switch (k)
{
float x, c, s, t, u, v;
cachepic_t *p, *dither;
- dither = Draw_CachePic("gfx/colorcontrol/ditherpattern", true);
+ dither = Draw_CachePic_Flags ("gfx/colorcontrol/ditherpattern", CACHEPICFLAG_NOCLAMP);
M_Background(320, 256);
M_DrawPic(16, 4, "gfx/qplaque");
- p = Draw_CachePic("gfx/p_option", true);
+ p = Draw_CachePic ("gfx/p_option");
M_DrawPic((320-p->width)/2, 4, "gfx/p_option");
optcursor = options_colorcontrol_cursor;
}
-static void M_Options_ColorControl_Key (int k, char ascii)
+static void M_Options_ColorControl_Key (int k, int ascii)
{
switch (k)
{
void M_Menu_Keys_f (void)
{
- key_dest = key_menu;
+ key_dest = key_menu_grabbed;
m_state = m_keys;
m_entersound = true;
}
M_Background(320, 48 + 8 * numcommands);
- p = Draw_CachePic ("gfx/ttl_cstm", true);
+ p = Draw_CachePic ("gfx/ttl_cstm");
M_DrawPic ( (320-p->width)/2, 4, "gfx/ttl_cstm");
if (bind_grab)
}
-static void M_Keys_Key (int k, char ascii)
+static void M_Keys_Key (int k, int ascii)
{
char cmd[80];
int keys[NUMKEYS];
}
else //if (k != '`')
{
- sprintf (cmd, "bind \"%s\" \"%s\"\n", Key_KeynumToString (k), bindnames[keys_cursor][0]);
+ dpsnprintf (cmd, sizeof(cmd), "bind \"%s\" \"%s\"\n", Key_KeynumToString (k), bindnames[keys_cursor][0]);
Cbuf_InsertText (cmd);
}
}
-static void M_Reset_Key (int key, char ascii)
+static void M_Reset_Key (int key, int ascii)
{
switch (key)
{
//=============================================================================
/* VIDEO MENU */
-// note: if modes are added to the beginning of this list, update VID_DEFAULT
-video_resolution_t video_resolutions[] =
+video_resolution_t video_resolutions_hardcoded[] =
{
{"Standard 4x3" , 320, 240, 320, 240, 1 },
{"Standard 4x3" , 400, 300, 400, 300, 1 },
{"WideScreen 16x9" , 683, 384, 683, 384, 1 },
{"WideScreen 16x9" , 960, 540, 640, 360, 1 },
{"WideScreen 16x9" , 1280, 720, 640, 360, 1 },
+{"WideScreen 16x9" , 1360, 768, 680, 384, 1 },
{"WideScreen 16x9" , 1366, 768, 683, 384, 1 },
{"WideScreen 16x9" , 1920,1080, 640, 360, 1 },
{"WideScreen 16x9" , 2560,1440, 640, 360, 1 },
{NULL, 0, 0, 0, 0, 0}
};
// this is the number of the default mode (640x480) in the list above
-#define VID_DEFAULT 3
-#define VID_RES_COUNT ((int)(sizeof(video_resolutions) / sizeof(video_resolutions[0])) - 1)
+int video_resolutions_hardcoded_count = sizeof(video_resolutions_hardcoded) / sizeof(*video_resolutions_hardcoded) - 1;
-#define VIDEO_ITEMS 10
+#define VIDEO_ITEMS 11
static int video_cursor = 0;
-static int video_cursor_table[] = {56, 68, 88, 100, 112, 132, 162, 170, 178, 186};
-static int video_resolution;
+static int video_cursor_table[VIDEO_ITEMS] = {68, 88, 96, 104, 112, 120, 128, 136, 144, 152, 168};
+static int menu_video_resolution;
-void M_Menu_Video_f (void)
+video_resolution_t *video_resolutions;
+int video_resolutions_count;
+
+static video_resolution_t *menu_video_resolutions;
+static int menu_video_resolutions_count;
+static qboolean menu_video_resolutions_forfullscreen;
+
+static void M_Menu_Video_FindResolution(int w, int h, float a)
{
int i;
- key_dest = key_menu;
- m_state = m_video;
- m_entersound = true;
+ if(menu_video_resolutions_forfullscreen)
+ {
+ menu_video_resolutions = video_resolutions;
+ menu_video_resolutions_count = video_resolutions_count;
+ }
+ else
+ {
+ menu_video_resolutions = video_resolutions_hardcoded;
+ menu_video_resolutions_count = video_resolutions_hardcoded_count;
+ }
// Look for the closest match to the current resolution
- video_resolution = 0;
- for (i = 1;i < VID_RES_COUNT;i++)
+ menu_video_resolution = 0;
+ for (i = 1;i < menu_video_resolutions_count;i++)
{
// if the new mode would be a worse match in width, skip it
- if (fabs(video_resolutions[i].width - vid.width) > fabs(video_resolutions[video_resolution].width - vid.width))
+ if (abs(menu_video_resolutions[i].width - w) > abs(menu_video_resolutions[menu_video_resolution].width - w))
continue;
// if it is equal in width, check height
- if (video_resolutions[i].width == vid.width && video_resolutions[video_resolution].width == vid.width)
+ if (menu_video_resolutions[i].width == w && menu_video_resolutions[menu_video_resolution].width == w)
{
// if the new mode would be a worse match in height, skip it
- if (fabs(video_resolutions[i].height - vid.height) > fabs(video_resolutions[video_resolution].height - vid.height))
+ if (abs(menu_video_resolutions[i].height - h) > abs(menu_video_resolutions[menu_video_resolution].height - h))
continue;
// if it is equal in width and height, check pixel aspect
- if (video_resolutions[i].height == vid.height && video_resolutions[video_resolution].height == vid.height)
+ if (menu_video_resolutions[i].height == h && menu_video_resolutions[menu_video_resolution].height == h)
{
// if the new mode would be a worse match in pixel aspect, skip it
- if (fabs(video_resolutions[i].pixelheight - vid_pixelheight.value) > fabs(video_resolutions[video_resolution].pixelheight - vid_pixelheight.value))
+ if (abs(menu_video_resolutions[i].pixelheight - a) > abs(menu_video_resolutions[menu_video_resolution].pixelheight - a))
continue;
// if it is equal in everything, skip it (prefer earlier modes)
- if (video_resolutions[i].pixelheight == vid_pixelheight.value && video_resolutions[video_resolution].pixelheight == vid_pixelheight.value)
+ if (menu_video_resolutions[i].pixelheight == a && menu_video_resolutions[menu_video_resolution].pixelheight == a)
continue;
// better match for width, height, and pixel aspect
- video_resolution = i;
+ menu_video_resolution = i;
}
else // better match for width and height
- video_resolution = i;
+ menu_video_resolution = i;
}
else // better match for width
- video_resolution = i;
+ menu_video_resolution = i;
}
}
+void M_Menu_Video_f (void)
+{
+ key_dest = key_menu;
+ m_state = m_video;
+ m_entersound = true;
+
+ M_Menu_Video_FindResolution(vid.width, vid.height, vid_pixelheight.value);
+}
+
static void M_Video_Draw (void)
{
+ int t;
cachepic_t *p;
+ if(!!vid_fullscreen.integer != menu_video_resolutions_forfullscreen)
+ {
+ video_resolution_t *res = &menu_video_resolutions[menu_video_resolution];
+ menu_video_resolutions_forfullscreen = !!vid_fullscreen.integer;
+ M_Menu_Video_FindResolution(res->width, res->height, res->pixelheight);
+ }
+
M_Background(320, 200);
M_DrawPic(16, 4, "gfx/qplaque");
- p = Draw_CachePic("gfx/vidmodes", true);
+ p = Draw_CachePic ("gfx/vidmodes");
M_DrawPic((320-p->width)/2, 4, "gfx/vidmodes");
- // Current Resolution
- M_Print(16, video_cursor_table[0], " Current Resolution");
- if (vid_supportrefreshrate && vid.fullscreen)
- M_Print(220, video_cursor_table[0], va("%dx%d %dhz", vid.width, vid.height, vid.refreshrate));
+ t = 0;
+
+ // Current and Proposed Resolution
+ M_Print(16, video_cursor_table[t] - 12, " Current Resolution");
+ if (vid_supportrefreshrate && vid.userefreshrate && vid.fullscreen)
+ M_Print(220, video_cursor_table[t] - 12, va("%dx%d %.2fhz", vid.width, vid.height, vid.refreshrate));
else
- M_Print(220, video_cursor_table[0], va("%dx%d", vid.width, vid.height));
+ M_Print(220, video_cursor_table[t] - 12, va("%dx%d", vid.width, vid.height));
+ M_Print(16, video_cursor_table[t], " New Resolution");
+ M_Print(220, video_cursor_table[t], va("%dx%d", menu_video_resolutions[menu_video_resolution].width, menu_video_resolutions[menu_video_resolution].height));
+ M_Print(96, video_cursor_table[t] + 8, va("Type: %s", menu_video_resolutions[menu_video_resolution].type));
+ t++;
- // Proposed Resolution
- M_Print(16, video_cursor_table[1], " New Resolution");
- M_Print(220, video_cursor_table[1], va("%dx%d", video_resolutions[video_resolution].width, video_resolutions[video_resolution].height));
- M_Print(96, video_cursor_table[1] + 8, va("Type: %s", video_resolutions[video_resolution].type));
+ // Bits per pixel
+ M_Print(16, video_cursor_table[t], " Bits per pixel");
+ M_Print(220, video_cursor_table[t], (vid_bitsperpixel.integer == 32) ? "32" : "16");
+ t++;
// Bits per pixel
- M_Print(16, video_cursor_table[2], " Bits per pixel");
- M_Print(220, video_cursor_table[2], (vid_bitsperpixel.integer == 32) ? "32" : "16");
+ M_Print(16, video_cursor_table[t], " Antialiasing");
+ M_DrawSlider(220, video_cursor_table[t], vid_samples.value, 1, 32);
+ t++;
// Refresh Rate
- M_ItemPrint(16, video_cursor_table[3], " Refresh Rate", vid_supportrefreshrate);
- M_DrawSlider(220, video_cursor_table[3], vid_refreshrate.integer, 60, 150);
+ M_ItemPrint(16, video_cursor_table[t], " Use Refresh Rate", vid_supportrefreshrate);
+ M_DrawCheckbox(220, video_cursor_table[t], vid_userefreshrate.integer);
+ t++;
- // Fullscreen
- M_Print(16, video_cursor_table[4], " Fullscreen");
- M_DrawCheckbox(220, video_cursor_table[4], vid_fullscreen.integer);
+ // Refresh Rate
+ M_ItemPrint(16, video_cursor_table[t], " Refresh Rate", vid_supportrefreshrate && vid_userefreshrate.integer);
+ M_DrawSlider(220, video_cursor_table[t], vid_refreshrate.value, 50, 150);
+ t++;
- // "Apply" button
- M_Print(220, video_cursor_table[5], "Apply");
+ // Fullscreen
+ M_Print(16, video_cursor_table[t], " Fullscreen");
+ M_DrawCheckbox(220, video_cursor_table[t], vid_fullscreen.integer);
+ t++;
// Vertical Sync
- M_ItemPrint(16, video_cursor_table[6], " Vertical Sync", gl_videosyncavailable);
- M_DrawCheckbox(220, video_cursor_table[6], vid_vsync.integer);
+ M_ItemPrint(16, video_cursor_table[t], " Vertical Sync", true);
+ M_DrawCheckbox(220, video_cursor_table[t], vid_vsync.integer);
+ t++;
- M_ItemPrint(16, video_cursor_table[7], " Anisotropic Filter", gl_support_anisotropy);
- M_DrawSlider(220, video_cursor_table[7], gl_texture_anisotropy.integer, 1, gl_max_anisotropy);
+ M_ItemPrint(16, video_cursor_table[t], " Anisotropic Filter", vid.support.ext_texture_filter_anisotropic);
+ M_DrawSlider(220, video_cursor_table[t], gl_texture_anisotropy.integer, 1, vid.max_anisotropy);
+ t++;
- M_ItemPrint(16, video_cursor_table[8], " Texture Quality", true);
- M_DrawSlider(220, video_cursor_table[8], gl_picmip.value, 3, 0);
+ M_ItemPrint(16, video_cursor_table[t], " Texture Quality", true);
+ M_DrawSlider(220, video_cursor_table[t], gl_picmip.value, 3, 0);
+ t++;
- M_ItemPrint(16, video_cursor_table[9], " Texture Compression", gl_support_texture_compression);
- M_DrawCheckbox(220, video_cursor_table[9], gl_texturecompression.integer);
+ M_ItemPrint(16, video_cursor_table[t], " Texture Compression", vid.support.arb_texture_compression);
+ M_DrawCheckbox(220, video_cursor_table[t], gl_texturecompression.integer);
+ t++;
+
+ // "Apply" button
+ M_Print(220, video_cursor_table[t], "Apply");
+ t++;
// Cursor
M_DrawCharacter(200, video_cursor_table[video_cursor], 12+((int)(realtime*4)&1));
static void M_Menu_Video_AdjustSliders (int dir)
{
+ int t;
+
S_LocalSound ("sound/misc/menu3.wav");
- switch (video_cursor)
+ t = 0;
+ if (video_cursor == t++)
{
// Resolution
- case 1:
+ int r;
+ for(r = 0;r < menu_video_resolutions_count;r++)
{
- int r;
- for(r = 0;r < VID_RES_COUNT;r++)
- {
- video_resolution += dir;
- if (video_resolution >= VID_RES_COUNT)
- video_resolution = 0;
- if (video_resolution < 0)
- video_resolution = VID_RES_COUNT - 1;
- if (video_resolutions[video_resolution].width >= vid_minwidth.integer && video_resolutions[video_resolution].height >= vid_minheight.integer)
- break;
- }
- break;
+ menu_video_resolution += dir;
+ if (menu_video_resolution >= menu_video_resolutions_count)
+ menu_video_resolution = 0;
+ if (menu_video_resolution < 0)
+ menu_video_resolution = menu_video_resolutions_count - 1;
+ if (menu_video_resolutions[menu_video_resolution].width >= vid_minwidth.integer && menu_video_resolutions[menu_video_resolution].height >= vid_minheight.integer)
+ break;
}
-
- // Bits per pixel
- case 2:
- Cvar_SetValueQuick (&vid_bitsperpixel, (vid_bitsperpixel.integer == 32) ? 16 : 32);
- break;
- // Refresh Rate
- case 3:
- Cvar_SetValueQuick (&vid_refreshrate, vid_refreshrate.integer + dir);
- break;
- case 4:
- Cvar_SetValueQuick (&vid_fullscreen, !vid_fullscreen.integer);
- break;
-
- case 6:
- Cvar_SetValueQuick (&vid_vsync, !vid_vsync.integer);
- break;
- case 7:
- Cvar_SetValueQuick (&gl_texture_anisotropy, bound(1, gl_texture_anisotropy.value * (dir < 0 ? 0.5 : 2.0), gl_max_anisotropy));
- break;
- case 8:
- Cvar_SetValueQuick (&gl_picmip, bound(0, gl_picmip.value - dir, 3));
- break;
- case 9:
- Cvar_SetValueQuick (&gl_texturecompression, !gl_texturecompression.integer);
- break;
}
+ else if (video_cursor == t++)
+ Cvar_SetValueQuick (&vid_bitsperpixel, (vid_bitsperpixel.integer == 32) ? 16 : 32);
+ else if (video_cursor == t++)
+ Cvar_SetValueQuick (&vid_samples, bound(1, vid_samples.value * (dir > 0 ? 2 : 0.5), 32));
+ else if (video_cursor == t++)
+ Cvar_SetValueQuick (&vid_userefreshrate, !vid_userefreshrate.integer);
+ else if (video_cursor == t++)
+ Cvar_SetValueQuick (&vid_refreshrate, bound(50, vid_refreshrate.value + dir, 150));
+ else if (video_cursor == t++)
+ Cvar_SetValueQuick (&vid_fullscreen, !vid_fullscreen.integer);
+ else if (video_cursor == t++)
+ Cvar_SetValueQuick (&vid_vsync, !vid_vsync.integer);
+ else if (video_cursor == t++)
+ Cvar_SetValueQuick (&gl_texture_anisotropy, bound(1, gl_texture_anisotropy.value * (dir < 0 ? 0.5 : 2.0), vid.max_anisotropy));
+ else if (video_cursor == t++)
+ Cvar_SetValueQuick (&gl_picmip, bound(0, gl_picmip.value - dir, 3));
+ else if (video_cursor == t++)
+ Cvar_SetValueQuick (&gl_texturecompression, !gl_texturecompression.integer);
}
-static void M_Video_Key (int key, char ascii)
+static void M_Video_Key (int key, int ascii)
{
switch (key)
{
// vid_shared.c has a copy of the current video config. We restore it
Cvar_SetValueQuick(&vid_fullscreen, vid.fullscreen);
Cvar_SetValueQuick(&vid_bitsperpixel, vid.bitsperpixel);
+ Cvar_SetValueQuick(&vid_samples, vid.samples);
if (vid_supportrefreshrate)
Cvar_SetValueQuick(&vid_refreshrate, vid.refreshrate);
+ Cvar_SetValueQuick(&vid_userefreshrate, vid.userefreshrate);
S_LocalSound ("sound/misc/menu1.wav");
M_Menu_Options_f ();
m_entersound = true;
switch (video_cursor)
{
- case 5:
- Cvar_SetValueQuick (&vid_width, video_resolutions[video_resolution].width);
- Cvar_SetValueQuick (&vid_height, video_resolutions[video_resolution].height);
- Cvar_SetValueQuick (&vid_conwidth, video_resolutions[video_resolution].conwidth);
- Cvar_SetValueQuick (&vid_conheight, video_resolutions[video_resolution].conheight);
- Cvar_SetValueQuick (&vid_pixelheight, video_resolutions[video_resolution].pixelheight);
+ case (VIDEO_ITEMS - 1):
+ Cvar_SetValueQuick (&vid_width, menu_video_resolutions[menu_video_resolution].width);
+ Cvar_SetValueQuick (&vid_height, menu_video_resolutions[menu_video_resolution].height);
+ Cvar_SetValueQuick (&vid_conwidth, menu_video_resolutions[menu_video_resolution].conwidth);
+ Cvar_SetValueQuick (&vid_conheight, menu_video_resolutions[menu_video_resolution].conheight);
+ Cvar_SetValueQuick (&vid_pixelheight, menu_video_resolutions[menu_video_resolution].pixelheight);
Cbuf_AddText ("vid_restart\n");
M_Menu_Options_f ();
break;
}
-static void M_Help_Key (int key, char ascii)
+static void M_Help_Key (int key, int ascii)
{
switch (key)
{
}
-static void M_Credits_Key (int key, char ascii)
+static void M_Credits_Key (int key, int ascii)
{
M_Menu_Main_f ();
}
break;
}
return 0;
-};
+}
void M_Menu_Quit_f (void)
{
int n;
if (m_state == m_quit)
return;
- wasInMenus = (key_dest == key_menu);
+ wasInMenus = (key_dest == key_menu || key_dest == key_menu_grabbed);
key_dest = key_menu;
m_quit_prevstate = m_state;
m_state = m_quit;
}
-static void M_Quit_Key (int key, char ascii)
+static void M_Quit_Key (int key, int ascii)
{
switch (key)
{
static int lanConfig_port;
static char lanConfig_portname[6];
-static char lanConfig_joinname[22];
+static char lanConfig_joinname[40];
void M_Menu_LanConfig_f (void)
{
if (StartingGame)
lanConfig_cursor = 1;
lanConfig_port = 26000;
- sprintf(lanConfig_portname, "%u", (unsigned int) lanConfig_port);
+ dpsnprintf(lanConfig_portname, sizeof(lanConfig_portname), "%u", (unsigned int) lanConfig_port);
M_Update_Return_Reason("");
}
M_Background(320, 200);
M_DrawPic (16, 4, "gfx/qplaque");
- p = Draw_CachePic ("gfx/p_multi", true);
+ p = Draw_CachePic ("gfx/p_multi");
basex = (320-p->width)/2;
M_DrawPic (basex, 4, "gfx/p_multi");
basex += 8;
M_Print(basex, lanConfig_cursor_table[0], "Port");
- M_DrawTextBox (basex+8*8, lanConfig_cursor_table[0]-8, 6, 1);
+ M_DrawTextBox (basex+8*8, lanConfig_cursor_table[0]-8, sizeof(lanConfig_portname), 1);
M_Print(basex+9*8, lanConfig_cursor_table[0], lanConfig_portname);
if (JoiningGame)
M_Print(basex, lanConfig_cursor_table[1], "Search for DarkPlaces games...");
M_Print(basex, lanConfig_cursor_table[2], "Search for QuakeWorld games...");
M_Print(basex, lanConfig_cursor_table[3]-16, "Join game at:");
- M_DrawTextBox (basex+8, lanConfig_cursor_table[3]-8, 22, 1);
+ M_DrawTextBox (basex+8, lanConfig_cursor_table[3]-8, sizeof(lanConfig_joinname), 1);
M_Print(basex+16, lanConfig_cursor_table[3], lanConfig_joinname);
}
else
}
-static void M_LanConfig_Key (int key, char ascii)
+static void M_LanConfig_Key (int key, int ascii)
{
int l;
if (lanConfig_cursor == 3)
{
l = (int)strlen(lanConfig_joinname);
- if (l < 21)
+ if (l < (int)sizeof(lanConfig_joinname) - 1)
{
lanConfig_joinname[l+1] = 0;
lanConfig_joinname[l] = ascii;
if (lanConfig_cursor == 0)
{
l = (int)strlen(lanConfig_portname);
- if (l < 5)
+ if (l < (int)sizeof(lanConfig_portname) - 1)
{
lanConfig_portname[l+1] = 0;
lanConfig_portname[l] = ascii;
l = atoi(lanConfig_portname);
if (l <= 65535)
lanConfig_port = l;
- sprintf(lanConfig_portname, "%u", (unsigned int) lanConfig_port);
+ dpsnprintf(lanConfig_portname, sizeof(lanConfig_portname), "%u", (unsigned int) lanConfig_port);
}
//=============================================================================
M_Background(320, 200);
M_DrawPic (16, 4, "gfx/qplaque");
- p = Draw_CachePic ("gfx/p_multi", true);
+ p = Draw_CachePic ("gfx/p_multi");
M_DrawPic ( (320-p->width)/2, 4, "gfx/p_multi");
M_DrawTextBox (152, 32, 10, 1);
}
}
-static void M_GameOptions_Key (int key, char ascii)
+static void M_GameOptions_Key (int key, int ascii)
{
gamelevels_t *g;
int l;
start = bound(0, slist_cursor - (visible >> 1), serverlist_viewcount - visible);
end = min(start + visible, serverlist_viewcount);
- p = Draw_CachePic("gfx/p_multi", true);
+ p = Draw_CachePic ("gfx/p_multi");
M_DrawPic((640 - p->width) / 2, 4, "gfx/p_multi");
if (end > start)
{
for (n = start;n < end;n++)
{
+ serverlist_entry_t *entry = ServerList_GetViewEntry(n);
DrawQ_Fill(menu_x, menu_y + y, 640, 16, n == slist_cursor ? (0.5 + 0.2 * sin(realtime * M_PI)) : 0, 0, 0, 0.5, 0);
- M_PrintColored(0, y, serverlist_viewlist[n]->line1);y += 8;
- M_PrintColored(0, y, serverlist_viewlist[n]->line2);y += 8;
+ M_PrintColored(0, y, entry->line1);y += 8;
+ M_PrintColored(0, y, entry->line2);y += 8;
}
}
else if (realtime - masterquerytime > 10)
}
-static void M_ServerList_Key(int k, char ascii)
+static void M_ServerList_Key(int k, int ascii)
{
switch (k)
{
case K_ENTER:
S_LocalSound ("sound/misc/menu2.wav");
if (serverlist_viewcount)
- Cbuf_AddText(va("connect \"%s\"\n", serverlist_viewlist[slist_cursor]->info.cname));
+ Cbuf_AddText(va("connect \"%s\"\n", ServerList_GetViewEntry(slist_cursor)->info.cname));
break;
default:
static int modlist_cursor;
//static int modlist_viewcount;
-#define MODLIST_TOTALSIZE 256
static int modlist_count = 0;
static modlist_entry_t modlist[MODLIST_TOTALSIZE];
stringlist_t list;
stringlistinit(&list);
- if (fs_basedir[0])
- listdirectory(&list, fs_basedir);
- else
- listdirectory(&list, "./");
+ listdirectory(&list, fs_basedir, "");
stringlistsort(&list);
modlist_count = 0;
modlist_numenabled = fs_numgamedirs;
start = bound(0, modlist_cursor - (visible >> 1), modlist_count - visible);
end = min(start + visible, modlist_count);
- p = Draw_CachePic("gfx/p_option", true);
+ p = Draw_CachePic ("gfx/p_option");
M_DrawPic((640 - p->width) / 2, 4, "gfx/p_option");
if (end > start)
{
}
}
-static void M_ModList_Key(int k, char ascii)
+static void M_ModList_Key(int k, int ascii)
{
switch (k)
{
//=============================================================================
/* Menu Subsystem */
-static void M_KeyEvent(int key, char ascii, qboolean downevent);
+static void M_KeyEvent(int key, int ascii, qboolean downevent);
static void M_Draw(void);
void M_ToggleMenu_f(void);
static void M_Shutdown(void);
void M_Draw (void)
{
- if (key_dest != key_menu)
+ if (key_dest != key_menu && key_dest != key_menu_grabbed)
m_state = m_none;
if (m_state == m_none)
g = (int)(realtime * 64)%96;
scale_y_rate = (float)(g+1) / 96;
top_offset = (g+12)/12;
- p = Draw_CachePic (va("gfx/menu/blooddrip%i", top_offset), true);
- drop1 = Draw_CachePic("gfx/menu/blooddrop1", true);
- drop2 = Draw_CachePic("gfx/menu/blooddrop2", true);
- drop3 = Draw_CachePic("gfx/menu/blooddrop3", true);
+ p = Draw_CachePic (va("gfx/menu/blooddrip%i", top_offset));
+ drop1 = Draw_CachePic ("gfx/menu/blooddrop1");
+ drop2 = Draw_CachePic ("gfx/menu/blooddrop2");
+ drop3 = Draw_CachePic ("gfx/menu/blooddrop3");
for (scale_x = 0; scale_x <= vid_conwidth.integer; scale_x += p->width) {
for (scale_y = -scale_y_repeat; scale_y <= vid_conheight.integer; scale_y += scale_y_repeat) {
DrawQ_Pic (scale_x + 21, scale_y_repeat * .5 + scale_y + scale_y_rate * scale_y_repeat, drop3, 0, 0, 1, 1, 1, 1, 0);
DrawQ_Pic (scale_x + 557, scale_y_repeat * .9425 + scale_y + scale_y_rate * scale_y_repeat, drop1, 0, 0, 1, 1, 1, 1, 0);
DrawQ_Pic (scale_x + 606, scale_y_repeat * .5 + scale_y + scale_y_rate * scale_y_repeat, drop2, 0, 0, 1, 1, 1, 1, 0);
}
- DrawQ_Pic (scale_x, -1, Draw_CachePic(va("gfx/menu/blooddrip%i", top_offset), true), 0, 0, 1, 1, 1, 1, 0);
+ DrawQ_Pic (scale_x, -1, Draw_CachePic (va("gfx/menu/blooddrip%i", top_offset)), 0, 0, 1, 1, 1, 1, 0);
}
}
}
}
-void M_KeyEvent (int key, char ascii, qboolean downevent)
+void M_KeyEvent (int key, int ascii, qboolean downevent)
{
if (!downevent)
return;
// init the normal menu now -> this will also correct the menu router pointers
MR_SetRouting (TRUE);
+ // reset the active scene, too (to be on the safe side ;))
+ R_SelectScene( RST_CLIENT );
+
Host_AbortCurrentFrame();
}
-void MP_KeyEvent (int key, char ascii, qboolean downevent)
+void MP_KeyEvent (int key, int ascii, qboolean downevent)
{
PRVM_Begin;
PRVM_SetProg(PRVM_MENUPROG);
void MP_Draw (void)
{
+ // declarations that are needed right now
+
+ float oldquality;
+
+ R_SelectScene( RST_MENU );
+
+ // reset the temp entities each frame
+ r_refdef.scene.numtempentities = 0;
+
+ // menu scenes do not use reduced rendering quality
+ oldquality = r_refdef.view.quality;
+ r_refdef.view.quality = 1;
+ // TODO: this needs to be exposed to R_SetView (or something similar) ASAP [2/5/2008 Andreas]
+ r_refdef.scene.time = realtime;
+
PRVM_Begin;
PRVM_SetProg(PRVM_MENUPROG);
+ // FIXME: this really shouldnt error out lest we have a very broken refdef state...?
+ // or does it kill the server too?
PRVM_ExecuteProgram(prog->funcoffsets.m_draw,"m_draw() required");
PRVM_End;
+
+ // TODO: imo this should be moved into scene, too [1/27/2008 Andreas]
+ r_refdef.view.quality = oldquality;
+
+ R_SelectScene( RST_CLIENT );
}
void MP_ToggleMenu_f (void)
PRVM_End;
}
-void MP_Fallback (void)
-{
- MP_Shutdown();
-
- key_dest = key_game;
-
- // init the normal menu now -> this will also correct the menu router pointers
- MR_SetRouting (TRUE);
-}
-
void MP_Init (void)
{
PRVM_Begin;
prog->init_cmd = VM_M_Cmd_Init;
prog->reset_cmd = VM_M_Cmd_Reset;
prog->error_cmd = MP_Error;
+ prog->ExecuteProgram = MVM_ExecuteProgram;
// allocate the mempools
prog->progs_mempool = Mem_AllocPool(M_PROG_FILENAME, 0, NULL);
// note: OP_STATE is not supported by menu qc, we don't even try to detect
// it here
+ in_client_mouse = true;
+
// call the prog init
PRVM_ExecuteProgram(prog->funcoffsets.m_init,"m_init() required");
//============================================================================
// Menu router
-void (*MR_KeyEvent) (int key, char ascii, qboolean downevent);
+void (*MR_KeyEvent) (int key, int ascii, qboolean downevent);
void (*MR_Draw) (void);
void (*MR_ToggleMenu_f) (void);
void (*MR_Shutdown) (void);
// set router console commands
Cvar_RegisterVariable (&forceqmenu);
Cvar_RegisterVariable (&menu_options_colorcontrol_correctionvalue);
- Cmd_AddCommand ("menu_restart",MR_Restart, "restart menu system (reloads menu.dat");
+ Cmd_AddCommand ("menu_restart",MR_Restart, "restart menu system (reloads menu.dat)");
Cmd_AddCommand ("togglemenu", Call_MR_ToggleMenu_f, "opens or closes menu");
}
void MR_Init(void)
{
+ vid_mode_t res[1024];
+ size_t res_count, i;
+
+ res_count = VID_ListModes(res, sizeof(res) / sizeof(*res));
+ res_count = VID_SortModes(res, res_count, false, false, true);
+ if(res_count)
+ {
+ video_resolutions_count = res_count;
+ video_resolutions = (video_resolution_t *) Mem_Alloc(cls.permanentmempool, sizeof(*video_resolutions) * (video_resolutions_count + 1));
+ memset(&video_resolutions[video_resolutions_count], 0, sizeof(video_resolutions[video_resolutions_count]));
+ for(i = 0; i < res_count; ++i)
+ {
+ int n, d, t;
+ video_resolutions[i].type = "Detected mode"; // FIXME make this more dynamic
+ video_resolutions[i].width = res[i].width;
+ video_resolutions[i].height = res[i].height;
+ video_resolutions[i].pixelheight = res[i].pixelheight_num / (double) res[i].pixelheight_denom;
+ n = res[i].pixelheight_denom * video_resolutions[i].width;
+ d = res[i].pixelheight_num * video_resolutions[i].height;
+ while(d)
+ {
+ t = n;
+ n = d;
+ d = t % d;
+ }
+ d = (res[i].pixelheight_num * video_resolutions[i].height) / n;
+ n = (res[i].pixelheight_denom * video_resolutions[i].width) / n;
+ switch(n * 0x10000 | d)
+ {
+ case 0x00040003:
+ video_resolutions[i].conwidth = 640;
+ video_resolutions[i].conheight = 480;
+ video_resolutions[i].type = "Standard 4x3";
+ break;
+ case 0x00050004:
+ video_resolutions[i].conwidth = 640;
+ video_resolutions[i].conheight = 512;
+ if(res[i].pixelheight_denom == res[i].pixelheight_num)
+ video_resolutions[i].type = "Square Pixel (LCD) 5x4";
+ else
+ video_resolutions[i].type = "Short Pixel (CRT) 5x4";
+ break;
+ case 0x00080005:
+ video_resolutions[i].conwidth = 640;
+ video_resolutions[i].conheight = 400;
+ if(res[i].pixelheight_denom == res[i].pixelheight_num)
+ video_resolutions[i].type = "Widescreen 8x5";
+ else
+ video_resolutions[i].type = "Tall Pixel (CRT) 8x5";
+
+ break;
+ case 0x00050003:
+ video_resolutions[i].conwidth = 640;
+ video_resolutions[i].conheight = 384;
+ video_resolutions[i].type = "Widescreen 5x3";
+ break;
+ case 0x000D0009:
+ video_resolutions[i].conwidth = 640;
+ video_resolutions[i].conheight = 400;
+ video_resolutions[i].type = "Widescreen 14x9";
+ break;
+ case 0x00100009:
+ video_resolutions[i].conwidth = 640;
+ video_resolutions[i].conheight = 480;
+ video_resolutions[i].type = "Widescreen 16x9";
+ break;
+ case 0x00030002:
+ video_resolutions[i].conwidth = 720;
+ video_resolutions[i].conheight = 480;
+ video_resolutions[i].type = "NTSC 3x2";
+ break;
+ case 0x000D000B:
+ video_resolutions[i].conwidth = 720;
+ video_resolutions[i].conheight = 566;
+ video_resolutions[i].type = "PAL 14x11";
+ break;
+ case 0x00080007:
+ if(video_resolutions[i].width >= 512)
+ {
+ video_resolutions[i].conwidth = 512;
+ video_resolutions[i].conheight = 448;
+ video_resolutions[i].type = "SNES 8x7";
+ }
+ else
+ {
+ video_resolutions[i].conwidth = 256;
+ video_resolutions[i].conheight = 224;
+ video_resolutions[i].type = "NES 8x7";
+ }
+ break;
+ default:
+ video_resolutions[i].conwidth = 640;
+ video_resolutions[i].conheight = 640 * d / n;
+ video_resolutions[i].type = "Detected mode";
+ break;
+ }
+ if(video_resolutions[i].conwidth > video_resolutions[i].width || video_resolutions[i].conheight > video_resolutions[i].height)
+ {
+ int f1, f2;
+ f1 = video_resolutions[i].conwidth > video_resolutions[i].width;
+ f2 = video_resolutions[i].conheight > video_resolutions[i].height;
+ if(f1 > f2)
+ {
+ video_resolutions[i].conwidth = video_resolutions[i].width;
+ video_resolutions[i].conheight = video_resolutions[i].conheight / f1;
+ }
+ else
+ {
+ video_resolutions[i].conwidth = video_resolutions[i].conwidth / f2;
+ video_resolutions[i].conheight = video_resolutions[i].height;
+ }
+ }
+ }
+ }
+ else
+ {
+ video_resolutions = video_resolutions_hardcoded;
+ video_resolutions_count = sizeof(video_resolutions_hardcoded) / sizeof(*video_resolutions_hardcoded) - 1;
+ }
+
+ menu_video_resolutions_forfullscreen = !!vid_fullscreen.integer;
+ M_Menu_Video_FindResolution(vid.width, vid.height, vid_pixelheight.value);
+
// use -forceqmenu to use always the normal quake menu (it sets forceqmenu to 1)
// COMMANDLINEOPTION: Client: -forceqmenu disables menu.dat (same as +forceqmenu 1)
if(COM_CheckParm("-forceqmenu"))
projects / xonotic / darkplaces.git / blobdiff