jediacademypc/code/unix/ui_video.c

#include "../client/client.h"
#include "../client/ui_local.h"

extern void UI_ForceMenuOff( void );

static const char *s_driver_names[] =
{
	"[default OpenGL]",
	"[Voodoo OpenGL]",
	"[Custom       ]",
	0
};

static const char *s_drivers[] =
{
	OPENGL_DRIVER_NAME,
	_3DFX_DRIVER_NAME,
	"",
	0
};

/*
====================================================================

MENU INTERACTION

====================================================================
*/
static menuframework_s	s_menu;

static menulist_s		s_graphics_options_list;
static menulist_s		s_mode_list;
static menulist_s		s_driver_list;
static menuslider_s		s_tq_slider;
static menulist_s  		s_fs_box;
static menulist_s  		s_lighting_box;
static menulist_s  		s_allow_extensions_box;
static menulist_s  		s_texturebits_box;
static menulist_s  		s_colordepth_list;
static menulist_s  		s_geometry_box;
static menulist_s  		s_filter_box;
static menuaction_s		s_driverinfo_action;
static menuaction_s		s_apply_action;
static menuaction_s		s_defaults_action;

typedef struct
{
	int mode;
	qboolean fullscreen;
	int tq;
	int lighting;
	int colordepth;
	int texturebits;
	int geometry;
	int filter;
	int driver;
	qboolean extensions;
} InitialVideoOptions_s;

static InitialVideoOptions_s s_ivo;

static InitialVideoOptions_s s_ivo_templates[] =
{
	{
		4, qtrue, 2, 0, 2, 2, 1, 1, 0, qtrue	// JDC: this was tq 3
	},
	{
		3, qtrue, 2, 0, 0, 0, 1, 0, 0, qtrue
	},
	{
		2, qtrue, 1, 0, 1, 0, 0, 0, 0, qtrue
	},
	{
		1, qtrue, 1, 1, 1, 0, 0, 0, 0, qtrue
	},
	{
		3, qtrue, 1, 0, 0, 0, 1, 0, 0, qtrue
	}
};

#define NUM_IVO_TEMPLATES ( sizeof( s_ivo_templates ) / sizeof( s_ivo_templates[0] ) )

static void DrvInfo_MenuDraw( void );
static const char * DrvInfo_MenuKey( int key );

static void GetInitialVideoVars( void )
{
	s_ivo.colordepth = s_colordepth_list.curvalue;
	s_ivo.driver = s_driver_list.curvalue;
	s_ivo.mode = s_mode_list.curvalue;
	s_ivo.fullscreen = s_fs_box.curvalue;
	s_ivo.extensions = s_allow_extensions_box.curvalue;
	s_ivo.tq = s_tq_slider.curvalue;
	s_ivo.lighting = s_lighting_box.curvalue;
	s_ivo.geometry = s_geometry_box.curvalue;
	s_ivo.filter = s_filter_box.curvalue;
	s_ivo.texturebits = s_texturebits_box.curvalue;
}

static void CheckConfigVsTemplates( void )
{
	int i;

	for ( i = 0; i < NUM_IVO_TEMPLATES; i++ )
	{
		if ( s_driver_list.curvalue != 1 )
			if ( s_ivo_templates[i].colordepth != s_colordepth_list.curvalue )
				continue;
#if 0
		if ( s_ivo_templates[i].driver != s_driver_list.curvalue )
			continue;
#endif
		if ( s_ivo_templates[i].mode != s_mode_list.curvalue )
			continue;
		if ( s_driver_list.curvalue != 1 )
			if ( s_ivo_templates[i].fullscreen != s_fs_box.curvalue )
				continue;
		if ( s_ivo_templates[i].tq != s_tq_slider.curvalue )
			continue;
		if ( s_ivo_templates[i].lighting != s_lighting_box.curvalue )
			continue;
		if ( s_ivo_templates[i].geometry != s_geometry_box.curvalue )
			continue;
		if ( s_ivo_templates[i].filter != s_filter_box.curvalue )
			continue;
//		if ( s_ivo_templates[i].texturebits != s_texturebits_box.curvalue )
//			continue;
		s_graphics_options_list.curvalue = i;
		return;
	}
	s_graphics_options_list.curvalue = 4;
}

static void UpdateMenuItemValues( void )
{
	if ( s_driver_list.curvalue == 1 )
	{
		s_fs_box.curvalue = 1;
		s_fs_box.generic.flags = QMF_GRAYED;
		s_colordepth_list.curvalue = 1;
	}
	else
	{
		s_fs_box.generic.flags = 0;
	}

	if ( s_fs_box.curvalue == 0 || s_driver_list.curvalue == 1 )
	{
		s_colordepth_list.curvalue = 0;
		s_colordepth_list.generic.flags = QMF_GRAYED;
	}
	else
	{
		s_colordepth_list.generic.flags = 0;
	}

	if ( s_allow_extensions_box.curvalue == 0 )
	{
		if ( s_texturebits_box.curvalue == 0 )
		{
			s_texturebits_box.curvalue = 1;
		}
	}

	s_apply_action.generic.flags = QMF_GRAYED;

	if ( s_ivo.mode != s_mode_list.curvalue )
	{
		s_apply_action.generic.flags = QMF_BLINK;
	}
	if ( s_ivo.fullscreen != s_fs_box.curvalue )
	{
		s_apply_action.generic.flags = QMF_BLINK;
	}
	if ( s_ivo.extensions != s_allow_extensions_box.curvalue )
	{
		s_apply_action.generic.flags = QMF_BLINK;
	}
	if ( s_ivo.tq != s_tq_slider.curvalue )
	{
		s_apply_action.generic.flags = QMF_BLINK;
	}
	if ( s_ivo.lighting != s_lighting_box.curvalue )
	{
		s_apply_action.generic.flags = QMF_BLINK;
	}
	if ( s_ivo.colordepth != s_colordepth_list.curvalue )
	{
		s_apply_action.generic.flags = QMF_BLINK;
	}
	if ( s_ivo.driver != s_driver_list.curvalue )
	{
		s_apply_action.generic.flags = QMF_BLINK;
	}
	if ( s_ivo.texturebits != s_texturebits_box.curvalue )
	{
		s_apply_action.generic.flags = QMF_BLINK;
	}
	if ( s_ivo.geometry != s_geometry_box.curvalue )
	{
		s_apply_action.generic.flags = QMF_BLINK;
	}
	if ( s_ivo.filter != s_filter_box.curvalue )
	{
		s_apply_action.generic.flags = QMF_BLINK;
	}

	CheckConfigVsTemplates();
}	

static void SetMenuItemValues( void )
{
	s_mode_list.curvalue = Cvar_VariableValue( "r_mode" );
	s_fs_box.curvalue = Cvar_VariableValue("r_fullscreen");
	s_allow_extensions_box.curvalue = Cvar_VariableValue("r_allowExtensions");
	s_tq_slider.curvalue = 3-Cvar_VariableValue( "r_picmip");
	if ( s_tq_slider.curvalue < 0 )
	{
	   s_tq_slider.curvalue = 0;
	}
	else if ( s_tq_slider.curvalue > 3 )
	{
	   s_tq_slider.curvalue = 3;
	}

	s_lighting_box.curvalue = Cvar_VariableValue( "r_vertexLight" ) != 0;
	switch ( ( int ) Cvar_VariableValue( "r_texturebits" ) )
	{
	case 0:
	default:
		s_texturebits_box.curvalue = 0;
		break;
	case 16:
		s_texturebits_box.curvalue = 1;
		break;
	case 32:
		s_texturebits_box.curvalue = 2;
		break;
	}

	if ( !Q_stricmp( Cvar_VariableString( "r_textureMode" ), "GL_LINEAR_MIPMAP_NEAREST" ) )
	{
		s_filter_box.curvalue = 0;
	}
	else
	{
		s_filter_box.curvalue = 1;
	}

	if ( Cvar_VariableValue( "r_subdivisions" ) == 999 ||
		 Cvar_VariableValue( "r_lodBias" ) > 0 )
	{
		s_geometry_box.curvalue = 0;
	}
	else
	{
		s_geometry_box.curvalue = 1;
	}

	switch ( ( int ) Cvar_VariableValue( "r_colorbits" ) )
	{
	default:
	case 0:
		s_colordepth_list.curvalue = 0;
		break;
	case 16:
		s_colordepth_list.curvalue = 1;
		break;
	case 32:
		s_colordepth_list.curvalue = 2;
		break;
	}

	if ( s_fs_box.curvalue == 0 )
	{
		s_colordepth_list.curvalue = 0;
	}
	if ( s_driver_list.curvalue == 1 )
	{
		s_colordepth_list.curvalue = 1;
	}
}

static void FullscreenCallback( void *s )
{
}

static void ModeCallback( void *s )
{
	// clamp 3dfx video modes
	if ( s_driver_list.curvalue == 1 )
	{
		if ( s_mode_list.curvalue < 2 )
		{
			s_mode_list.curvalue = 2;
		}
		else if ( s_mode_list.curvalue > 6 )
		{
			s_mode_list.curvalue = 6;
		}
	}
}

static void GraphicsOptionsCallback( void *s )
{
	InitialVideoOptions_s *ivo = &s_ivo_templates[s_graphics_options_list.curvalue];

	s_mode_list.curvalue = ivo->mode;
	s_tq_slider.curvalue = ivo->tq;
	s_lighting_box.curvalue = ivo->lighting;
	s_colordepth_list.curvalue = ivo->colordepth;
	s_texturebits_box.curvalue = ivo->texturebits;
	s_geometry_box.curvalue = ivo->geometry;
	s_filter_box.curvalue = ivo->filter;
	s_fs_box.curvalue = ivo->fullscreen;
}

static void TextureDetailCallback( void *s )
{
}

static void TextureQualityCallback( void *s )
{
}

static void ExtensionsCallback( void *s )
{
}

static void ColorDepthCallback( void *s )
{
}

static void DriverInfoCallback( void *s )
{
	UI_PushMenu( DrvInfo_MenuDraw, DrvInfo_MenuKey );
}

static void LightingCallback( void * s )
{
}

static void ApplyChanges( void *unused )
{
	switch ( s_texturebits_box.curvalue  )
	{
	case 0:
		Cvar_SetValue( "r_texturebits", 0 );
		Cvar_SetValue( "r_ext_compress_textures", 1 );
		break;
	case 1:
		Cvar_SetValue( "r_texturebits", 16 );
		Cvar_SetValue( "r_ext_compress_textures", 0 );
		break;
	case 2:
		Cvar_SetValue( "r_texturebits", 32 );
		Cvar_SetValue( "r_ext_compress_textures", 0 );
		break;
	}
	Cvar_SetValue( "r_picmip", 3 - s_tq_slider.curvalue );
	Cvar_SetValue( "r_allowExtensions", s_allow_extensions_box.curvalue );
	Cvar_SetValue( "r_mode", s_mode_list.curvalue );
	Cvar_SetValue( "r_fullscreen", s_fs_box.curvalue );
	if (*s_drivers[s_driver_list.curvalue] )
		Cvar_Set( "r_glDriver", ( char * ) s_drivers[s_driver_list.curvalue] );
	switch ( s_colordepth_list.curvalue )
	{
	case 0:
		Cvar_SetValue( "r_colorbits", 0 );
		Cvar_SetValue( "r_depthbits", 0 );
		Cvar_SetValue( "r_stencilbits", 0 );
		break;
	case 1:
		Cvar_SetValue( "r_colorbits", 16 );
		Cvar_SetValue( "r_depthbits", 16 );
		Cvar_SetValue( "r_stencilbits", 0 );
		break;
	case 2:
		Cvar_SetValue( "r_colorbits", 32 );
		Cvar_SetValue( "r_depthbits", 24 );
		break;
	}
	Cvar_SetValue( "r_vertexLight", s_lighting_box.curvalue );

	if ( s_geometry_box.curvalue )
	{
		Cvar_SetValue( "r_lodBias", 0 );
		Cvar_SetValue( "r_subdivisions", 4 );
	}
	else
	{
		Cvar_SetValue( "r_lodBias", 1 );
		Cvar_SetValue( "r_subdivisions", 999 );
	}

	if ( s_filter_box.curvalue )
	{
		Cvar_Set( "r_textureMode", "GL_LINEAR_MIPMAP_LINEAR" );
	}
	else
	{
		Cvar_Set( "r_textureMode", "GL_LINEAR_MIPMAP_NEAREST" );
	}

	UI_ForceMenuOff();

	CL_Vid_Restart_f();

	VID_MenuInit();

//	s_fs_box.curvalue = Cvar_VariableValue( "r_fullscreen" );
}

/*
** VID_MenuInit
*/
void VID_MenuInit( void )
{
	static const char *tq_names[] =
	{
		"compressed",
		"16-bit",
		"32-bit",
		0
	};

	static const char *s_graphics_options_names[] =
	{
		"high quality",
		"normal",
		"fast",
		"fastest",
		"custom",
		0
	};

	static const char *lighting_names[] =
	{
		"lightmap",
		"vertex",
		0
	};

	static const char *colordepth_names[] =
	{
		"default",
		"16-bit",
		"32-bit",
		0
	};

	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]",
		"[856 480 W]",
		0
	};
	static const char *filter_names[] =
	{
		"bilinear",
		"trilinear",
		0
	};
	static const char *quality_names[] =
	{
		"low",
		"high",
		0
	};
	static const char *enabled_names[] =
	{
		"disabled",
		"enabled",
		0
	};
	int y = 0;
	int i;
	char *p;

	s_menu.x = SCREEN_WIDTH * 0.50;
	s_menu.nitems = 0;
	s_menu.wrapAround = qtrue;

	s_graphics_options_list.generic.type = MTYPE_SPINCONTROL;
	s_graphics_options_list.generic.name = "graphics mode";
	s_graphics_options_list.generic.x = 0;
	s_graphics_options_list.generic.y = y;
	s_graphics_options_list.generic.callback = GraphicsOptionsCallback;
	s_graphics_options_list.itemnames = s_graphics_options_names;

	s_driver_list.generic.type = MTYPE_SPINCONTROL;
	s_driver_list.generic.name = "driver";
	s_driver_list.generic.x = 0;
	s_driver_list.generic.y = y += 18;

	p = Cvar_VariableString( "r_glDriver" );
	for (i = 0; s_drivers[i]; i++) {
		if (strcmp(s_drivers[i], p) == 0)
			break;
	}
	if (!s_drivers[i])
		i--; // go back one, to default 'custom'
	s_driver_list.curvalue = i;

	s_driver_list.itemnames = s_driver_names;

	// references/modifies "r_allowExtensions"
	s_allow_extensions_box.generic.type = MTYPE_SPINCONTROL;
	s_allow_extensions_box.generic.x	= 0;
	s_allow_extensions_box.generic.y	= y += 18;
	s_allow_extensions_box.generic.name	= "OpenGL extensions";
	s_allow_extensions_box.generic.callback = ExtensionsCallback;
	s_allow_extensions_box.itemnames = enabled_names;

	// references/modifies "r_mode"
	s_mode_list.generic.type = MTYPE_SPINCONTROL;
	s_mode_list.generic.name = "video mode";
	s_mode_list.generic.x = 0;
	s_mode_list.generic.y = y += 36;
	s_mode_list.itemnames = resolutions;
	s_mode_list.generic.callback = ModeCallback;

	// references "r_colorbits"
	s_colordepth_list.generic.type = MTYPE_SPINCONTROL;
	s_colordepth_list.generic.name = "color depth";
	s_colordepth_list.generic.x = 0;
	s_colordepth_list.generic.y = y += 18;
	s_colordepth_list.itemnames = colordepth_names;
	s_colordepth_list.generic.callback = ColorDepthCallback;

	// references/modifies "r_fullscreen"
	s_fs_box.generic.type = MTYPE_RADIOBUTTON;
	s_fs_box.generic.x	= 0;
	s_fs_box.generic.y	= y += 18;
	s_fs_box.generic.name	= "fullscreen";
	s_fs_box.generic.callback = FullscreenCallback;

	// references/modifies "r_vertexLight"
	s_lighting_box.generic.type = MTYPE_SPINCONTROL;
	s_lighting_box.generic.x	= 0;
	s_lighting_box.generic.y	= y += 18;
	s_lighting_box.generic.name	= "lighting";
	s_lighting_box.itemnames = lighting_names;
	s_lighting_box.generic.callback = LightingCallback;

	// references/modifies "r_lodBias" & "subdivisions"
	s_geometry_box.generic.type = MTYPE_SPINCONTROL;
	s_geometry_box.generic.x	= 0;
	s_geometry_box.generic.y	= y += 18;
	s_geometry_box.generic.name	= "geometric detail";
	s_geometry_box.itemnames = quality_names;

	// references/modifies "r_picmip"
	s_tq_slider.generic.type	= MTYPE_SLIDER;
	s_tq_slider.generic.x		= 0;
	s_tq_slider.generic.y		= y += 18;
	s_tq_slider.generic.name	= "texture detail";
	s_tq_slider.generic.callback = TextureDetailCallback;
	s_tq_slider.minvalue = 0;
	s_tq_slider.maxvalue = 3;

	// references/modifies "r_textureBits"
	s_texturebits_box.generic.type = MTYPE_SPINCONTROL;
	s_texturebits_box.generic.x	= 0;
	s_texturebits_box.generic.y	= y += 18;
	s_texturebits_box.generic.name	= "texture quality";
	s_texturebits_box.generic.callback = TextureQualityCallback;
	s_texturebits_box.itemnames = tq_names;

	// references/modifies "r_textureMode"
	s_filter_box.generic.type = MTYPE_SPINCONTROL;
	s_filter_box.generic.x	= 0;
	s_filter_box.generic.y	= y += 18;
	s_filter_box.generic.name	= "texture filter";
	s_filter_box.itemnames = filter_names;

	s_driverinfo_action.generic.type = MTYPE_ACTION;
	s_driverinfo_action.generic.name = "driver information";
	s_driverinfo_action.generic.x    = 0;
	s_driverinfo_action.generic.y    = y += 36;
	s_driverinfo_action.generic.callback = DriverInfoCallback;

	s_apply_action.generic.type = MTYPE_ACTION;
	s_apply_action.generic.name = "apply";
	s_apply_action.generic.x    = 0;
	s_apply_action.generic.y    = y += 36;
	s_apply_action.generic.callback = ApplyChanges;
	s_apply_action.generic.flags = QMF_GRAYED;

	SetMenuItemValues();
	GetInitialVideoVars();

	Menu_AddItem( &s_menu, ( void * ) &s_graphics_options_list );
	Menu_AddItem( &s_menu, ( void * ) &s_driver_list );
	Menu_AddItem( &s_menu, ( void * ) &s_allow_extensions_box );
	Menu_AddItem( &s_menu, ( void * ) &s_mode_list );
	Menu_AddItem( &s_menu, ( void * ) &s_colordepth_list );
	Menu_AddItem( &s_menu, ( void * ) &s_fs_box );
	Menu_AddItem( &s_menu, ( void * ) &s_lighting_box );
	Menu_AddItem( &s_menu, ( void * ) &s_geometry_box );
	Menu_AddItem( &s_menu, ( void * ) &s_tq_slider );
	Menu_AddItem( &s_menu, ( void * ) &s_texturebits_box );
	Menu_AddItem( &s_menu, ( void * ) &s_filter_box );

	Menu_AddItem( &s_menu, ( void * ) &s_driverinfo_action );
	Menu_AddItem( &s_menu, ( void * ) &s_apply_action );

	Menu_Center( &s_menu );
	s_menu.y -= 6;
}

/*
================
VID_MenuDraw
================
*/
void VID_MenuDraw (void)
{
	UpdateMenuItemValues();
	Menu_AdjustCursor( &s_menu, 1 );
	Menu_Draw( &s_menu );
}

/*
================
VID_MenuKey
================
*/
const char *VID_MenuKey( int key )
{
	menuframework_s *m = &s_menu;
	static const char *sound = "sound/misc/menu1.wav";

	if ( key == K_ENTER )
	{
		if ( !Menu_SelectItem( m ) )
			ApplyChanges( NULL );
		return NULL;
	}
	return Default_MenuKey( m, key );

}

static void DrvInfo_MenuDraw( void )
{
	float labelColor[] = { 0, 1.0, 0, 1.0 };
	float textColor[] = { 1, 1, 1, 1 };
	int i = 14;
	char extensionsString[1024], *eptr = extensionsString;

	SCR_DrawBigStringColor( BIGCHAR_WIDTH * 4, BIGCHAR_HEIGHT * 3, "VENDOR:", labelColor );
	SCR_DrawBigStringColor( BIGCHAR_WIDTH * 4, BIGCHAR_HEIGHT * 4, Cvar_VariableString( "gl_vendor" ), textColor );
	SCR_DrawBigStringColor( BIGCHAR_WIDTH * 4, BIGCHAR_HEIGHT * 5.5, "VERSION:", labelColor );
	SCR_DrawBigStringColor( BIGCHAR_WIDTH * 4, BIGCHAR_HEIGHT * 6.5, Cvar_VariableString( "gl_version" ), textColor );
	SCR_DrawBigStringColor( BIGCHAR_WIDTH * 4, BIGCHAR_HEIGHT * 8, "RENDERER:", labelColor );
	SCR_DrawBigStringColor( BIGCHAR_WIDTH * 4, BIGCHAR_HEIGHT * 9, Cvar_VariableString( "gl_renderer" ), textColor );
	SCR_DrawBigStringColor( BIGCHAR_WIDTH * 4, BIGCHAR_HEIGHT * 10.5, "PIXELFORMAT:", labelColor );
	SCR_DrawBigStringColor( BIGCHAR_WIDTH * 4, BIGCHAR_HEIGHT * 11.5, Cvar_VariableString( "gl_pixelformat" ), textColor );

	SCR_DrawBigStringColor( BIGCHAR_WIDTH * 4, BIGCHAR_HEIGHT * 13, "EXTENSIONS:", labelColor );
	strcpy( extensionsString, Cvar_VariableString( "gl_extensions" ) );
	while ( i < 25 && *eptr )
	{
		while ( *eptr )
		{
			char buf[2] = " ";
			int j = BIGCHAR_WIDTH * 6;

			while ( *eptr && *eptr != ' ' )
			{
				buf[0] = *eptr;
				SCR_DrawBigStringColor( j, i * BIGCHAR_HEIGHT, buf, textColor );
				j += BIGCHAR_WIDTH;
				eptr++;
			}

			i++;

			while ( *eptr && *eptr == ' ' )
				eptr++;
		}
	}
}

static const char * DrvInfo_MenuKey( int key )
{
	if ( key == K_ESCAPE )
		UI_PopMenu();
	return NULL;
}