Reworked 2D pic drawing using a new, merged R_DrawPic() function. Moved old pic drawing functions to r_draw_removed.c.

Added new SCR_DrawPic() variants in cl_screen.c.
Added new graphics for text fields and sliders in menus.
Improved mouse interaction for menu sliders.
Added resettargets developer command to default Lazarus and  missionpack DLLs.
Added hint_test developer command to missionpack DLL.
Fixed freeze developer command in default Lazarus and missionpack DLLs so it can be used more than once.
More tweaks to Tactician Gunner prox mine safety checks in misssionpack DLL.

client/cl_cinematic.c

@@ -1479,6 +1479,7 @@ CIN_DrawCinematic
 void CIN_DrawCinematic (cinHandle_t handle){
 
 	cinematic_t	*cin;
+	drawStruct_t	ds;
 
 	cin = CIN_GetVideoByHandle(handle);
 
@@ -1488,14 +1489,22 @@ void CIN_DrawCinematic (cinHandle_t handle){
 	if (cin->frameCount == -1) // Knightmare- HACK to show JPG endscreens
 	{
 		char	picname[MAX_QPATH] = "/";
-		float	x=0, y=0, w=640, h=480;
+		float	x=0, y=0, w=SCREEN_WIDTH, h=SCREEN_HEIGHT;
+
 	//	strncat(picname, cin->name);
 		Q_strncatz (picname, sizeof(picname), cin->name);
 		SCR_ScaleCoords (&x, &y, &w, &h, ALIGN_CENTER);
 		if (w < viddef.width || h < viddef.height)
 			R_DrawFill (0, 0, viddef.width, viddef.height, 0, 0, 0, 255);
-	//	R_DrawStretchPic (x, y, viddef.width, viddef.height, picname, 1.0);
+
-		R_DrawStretchPic (x, y, w, h, picname, 1.0);
+		memset (&ds, 0, sizeof(drawStruct_t));
+		ds.pic = &picname[0];
+		ds.x = x;	ds.y = y;	ds.w = w;	ds.h = h;
+		Vector2Copy (vec2_origin, ds.offset);
+		Vector4Copy (vec4_identity, ds.color);
+
+		R_DrawPic (ds);
+	//	R_DrawStretchPic (x, y, w, h, picname, 1.0);
 		return;
 	} // end JPG hack
 

client/cl_console.c

@@ -27,13 +27,8 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 console_t	con;
 
 cvar_t		*con_notifytime;
-cvar_t		*con_alpha;		// Knightare- Psychospaz's transparent console
-//cvar_t		*con_height;	// Knightmare- how far the console drops down
-cvar_t		*con_newconback;	// whether to use new console background
-cvar_t		*con_oldconbar;		// whether to draw bottom bar on old console
 qboolean	newconback_found = false;	// whether to draw Q3-style console
 
-
 extern	char	key_lines[32][MAXCMDLINE];
 extern	int		edit_line;
 extern	int		key_linepos;
@@ -333,15 +328,12 @@ void Con_Init (void)
 	con_notifytime = Cvar_Get ("con_notifytime", "4", 0); // Knightmare- increased for fade
 	Cvar_SetDescription ("con_notifytime", "Time in seconds for console notify messages to fade away.");
 
-	// Knightmare- Psychospaz's transparent console
+	Cmd_AddCommand ("toggleconsole", Con_ToggleConsole_f);
-	con_alpha = Cvar_Get ("con_alpha", "0.5", CVAR_ARCHIVE);
+	Cmd_AddCommand ("togglechat", Con_ToggleChat_f);
-	Cvar_SetDescription ("con_alpha", "Opacity of console background.");
+	Cmd_AddCommand ("messagemode", Con_MessageMode_f);
-	// Knightmare- how far the console drops down
+	Cmd_AddCommand ("messagemode2", Con_MessageMode2_f);
-	//con_height = Cvar_Get ("con_height", "0.5", CVAR_ARCHIVE);
+	Cmd_AddCommand ("clear", Con_Clear_f);
-	con_newconback = Cvar_Get ("con_newconback", "0", CVAR_ARCHIVE);	// whether to use new console background
+	Cmd_AddCommand ("condump", Con_Dump_f);
-	Cvar_SetDescription ("con_newconback", "Toggles use of new console background.");
-	con_oldconbar = Cvar_Get ("con_oldconbar", "1", CVAR_ARCHIVE);		// whether to draw bottom bar on old console
-	Cvar_SetDescription ("con_oldconbar", "Toggles drawing of solid color bottom bar on console with standard conback image.");
 
 	// whether to use new-style console background
 	newconback_found = false;
@@ -352,13 +344,6 @@ void Con_Init (void)
 		|| (FS_LoadFile("gfx/ui/newconback.jpg", NULL) != -1) )
 		newconback_found = true;
 
-	Cmd_AddCommand ("toggleconsole", Con_ToggleConsole_f);
-	Cmd_AddCommand ("togglechat", Con_ToggleChat_f);
-	Cmd_AddCommand ("messagemode", Con_MessageMode_f);
-	Cmd_AddCommand ("messagemode2", Con_MessageMode2_f);
-	Cmd_AddCommand ("clear", Con_Clear_f);
-	Cmd_AddCommand ("condump", Con_Dump_f);
-
 	con.initialized = true;
 }
 
@@ -901,6 +886,8 @@ void Con_DrawConsole (float frac, qboolean trans)
 	float			alpha, barheight, conLeft, conWidth, picLeft, picWidth, picHeight, pboxWidth;
 	// changeable download bar color
 	int				red, green, blue;
+	vec4_t			picColor;
+	drawStruct_t	ds;
 
 //	CL_TextColor ((int)alt_text_color->value, &red, &green, &blue);
 	CL_TextColor (alt_text_color->integer, &red, &green, &blue);
@@ -911,8 +898,8 @@ void Con_DrawConsole (float frac, qboolean trans)
 	picHeight = SCREEN_HEIGHT;
 	SCR_ScaleCoords (&picLeft, NULL, &picWidth, &picHeight, ALIGN_CENTER);
 
-//	if ( (newconback_found && con_newconback->value) || con_oldconbar->value ) {
+//	if ( (newconback_found && scr_newconback->value) || scr_oldconbar->value ) {
-	if ( (newconback_found && con_newconback->integer) || con_oldconbar->integer ) {
+	if ( (newconback_found && scr_newconback->integer) || scr_oldconbar->integer ) {
 		barheight = 2;
 		SCR_ScaleCoords (&conLeft, NULL, &conWidth, &barheight, ALIGN_STRETCH);
 	}
@@ -929,20 +916,40 @@ void Con_DrawConsole (float frac, qboolean trans)
 		lines = viddef.height;
 
 	// Psychospaz's transparent console
-	//alpha = (trans) ? ((frac/ (newconback_found?0.5:con_height->value) )*con_alpha->value) : 1;
+	//alpha = (trans) ? ((frac/ (newconback_found?0.5:scr_conheight->value) )*scr_conalpha->value) : 1;
-//	alpha = trans ? ((newconback_found && con_newconback->value) ? con_alpha->value : 2*frac*con_alpha->value) : 1;
+//	alpha = trans ? ((newconback_found && scr_newconback->value) ? scr_conalpha->value : 2*frac*scr_conalpha->value) : 1;
-	alpha = trans ? ((newconback_found && con_newconback->integer) ? con_alpha->value : 2*frac*con_alpha->value) : 1;
+	alpha = trans ? ((newconback_found && scr_newconback->integer) ? scr_conalpha->value : 2*frac*scr_conalpha->value) : 1;
+	Vector4Set (picColor, 1.0f, 1.0f, 1.0f, alpha);
 
 	// draw the background
-	//i = newconback_found ? lines - barheight : lines*(1/con_height->value);
+	//i = newconback_found ? lines - barheight : lines*(1/scr_conheight->value);
-	//j = newconback_found ? 0 : (con_height->value-1)*i - barheight;
+	//j = newconback_found ? 0 : (scr_conheight->value-1)*i - barheight;
 	y = lines - barheight;
+
+	memset (&ds, 0, sizeof(drawStruct_t));
+	Vector2Copy (vec2_origin, ds.offset);
+	Vector4Copy (picColor, ds.color);
+
 	if (y < 1)	y = 0;
-//	else if (newconback_found && con_newconback->value)	// Q3-style console
+/*	else if (newconback_found && scr_newconback->integer)	// Q3-style console
-	else if (newconback_found && con_newconback->integer)	// Q3-style console
 		R_DrawStretchPic ((int)picLeft, 0, picWidth, lines-barheight, "/gfx/ui/newconback.pcx", alpha);
 	else
 		R_DrawStretchPic ((int)picLeft, (lines-(int)picHeight-(int)barheight), picWidth, (int)picHeight, "conback", alpha);
+*/
+	else if (newconback_found && scr_newconback->integer)	{ // Q3-style console
+		ds.pic = "/gfx/ui/newconback.pcx";
+	//	ds.x = (int)conLeft;	ds.w = conWidth;
+		ds.x = (int)picLeft;	ds.w = picWidth;
+		ds.y = 0;	ds.h = lines-(int)barheight;
+		R_DrawPic (ds);
+	}
+	else {
+		ds.pic = "conback";
+	//	ds.x = (int)conLeft;	ds.w = conWidth;
+		ds.x = (int)picLeft;	ds.w = picWidth;
+		ds.y = (lines-(int)picHeight-(int)barheight);	ds.h = (int)picHeight;
+		R_DrawPic (ds);
+	}
 
 	// pillarbox sides if console is wider than scaled pic
 	if (conWidth > picWidth)
@@ -961,8 +968,8 @@ void Con_DrawConsole (float frac, qboolean trans)
 
 	Con_DrawString ((int)(conLeft+conWidth)-FONT_SIZE*(stringLen((const char *)&version))-3, y-(int)(1.25*FONT_SIZE), version, FONT_CONSOLE, 255);
 
-//	if ( (newconback_found && con_newconback->value) || con_oldconbar->value ) // Q3-style console bottom bar
+//	if ( (newconback_found && scr_newconback->value) || scr_oldconbar->value ) // Q3-style console bottom bar
-	if ( (newconback_found && con_newconback->integer) || con_oldconbar->integer ) // Q3-style console bottom bar
+	if ( (newconback_found && scr_newconback->integer) || scr_oldconbar->integer ) // Q3-style console bottom bar
 		R_DrawFill ((int)conLeft, y, conWidth, barheight, red, green, blue, 255);
 
 	// draw the text
@@ -973,7 +980,7 @@ void Con_DrawConsole (float frac, qboolean trans)
 	// draw from the bottom up
 	if (con.display != con.current)
 	{
-	// draw arrows to show the buffer is backscrolled
+		// draw arrows to show the buffer is backscrolled
 		for (x = 0; x < con.linewidth; x+=4)
 			R_DrawChar ((int)conLeft + (x+1)*FONT_SIZE, y, '^', FONT_CONSOLE, CON_FONT_SCALE, 255, 0, 0, 255, false, ((x+4)>=con.linewidth) );
 	
@@ -1015,5 +1022,3 @@ void Con_DrawConsole (float frac, qboolean trans)
 	// draw the input prompt, user text, and cursor if desired
 	Con_DrawInput ();
 }
-
-

client/cl_hud.c

@@ -71,6 +71,26 @@ void Hud_DrawStringAlt (int x, int y, const char *string, int alpha, qboolean is
 //	CL_DrawStringGeneric (x, y, string, alpha, HUD_FONT_SIZE, (isStatusBar) ? SCALETYPE_HUD : SCALETYPE_MENU, true);
 }
 
+
+/*
+================
+Hud_DrawStringFromCharsPic
+================
+*/
+void Hud_DrawStringFromCharsPic (float x, float y, float w, float h, vec2_t offset, float width, scralign_t align, char *string, color_t color, char *pic, int flags)
+{
+	vec2_t	scaledOffset;
+
+	Vector2Copy (offset, scaledOffset);
+	SCR_ScaleCoords (&x, &y, &w, &h, align);
+//	SCR_ScaleCoords (NULL, NULL, &offsetX, NULL, align);
+//	SCR_ScaleCoords (NULL, NULL, NULL, &offsetY, align);
+	SCR_ScaleCoords (NULL, NULL, &scaledOffset[0], &scaledOffset[1], align);
+	SCR_ScaleCoords (NULL, NULL, &width, NULL, align);
+
+	CL_DrawStringFromCharsPic (x, y, w, h, scaledOffset, width, string, color, pic, flags);
+}
+
 /*
 ===============================================================
 
@@ -194,12 +214,14 @@ Draws HUD number displays
 */
 void CL_DrawLayoutField (int x, int y, int color, int width, int value, qboolean flash, qboolean isStatusBar)
 {
-	char		num[16], *ptr;
+	char			num[16], *ptr;
-	int			l, frame;
+	int				l, frame;
-	float		digitWidth, digitOffset, fieldScale;
+	float			digitWidth, digitOffset, fieldScale;
-	float		flash_x, flashWidth;
+	float			flash_x, flashWidth;
-	float		(*scaleForScreen)(float in);
+	vec4_t			picColor;
-	float		(*getScreenScale)(void);
+	drawStruct_t	ds;
+	float			(*scaleForScreen)(float in);
+	float			(*getScreenScale)(void);
 
 	if (width < 1)
 		return;
@@ -233,14 +255,23 @@ void CL_DrawLayoutField (int x, int y, int color, int width, int value, qboolean
 	}
 	digitWidth = fieldScale*(float)CHAR_WIDTH;
 	digitOffset = width*scaleForScreen(CHAR_WIDTH) - l*digitWidth;
-//	x += 2 + scaledHud(CHAR_WIDTH)*(width - l);
 //	x += 2 + scaleForScreen(CHAR_WIDTH)*(width - l);
 	x += 2 + digitOffset;
-	flashWidth = l*digitWidth;
+	flashWidth = l * digitWidth;
 	flash_x = x;
+	Vector4Set (picColor, 1.0f, 1.0f, 1.0f, scr_hudalpha->value);
 
-	if (flash)
+	memset (&ds, 0, sizeof(drawStruct_t));
-		R_DrawStretchPic (flash_x, y, flashWidth, scaleForScreen(ICON_HEIGHT), "field_3", scr_hudalpha->value);
+	ds.y = y;	ds.h = scaleForScreen(ICON_HEIGHT);
+	Vector2Copy (vec2_origin, ds.offset);
+	Vector4Copy (picColor, ds.color);
+
+	if (flash){
+		ds.pic = "field_3";
+		ds.x = flash_x;	ds.w = flashWidth;	
+		R_DrawPic (ds);
+	//	R_DrawStretchPic (flash_x, y, flashWidth, scaleForScreen(ICON_HEIGHT), "field_3", scr_hudalpha->value);
+	}
 
 	ptr = num;
 	while (*ptr && l)
@@ -250,11 +281,10 @@ void CL_DrawLayoutField (int x, int y, int color, int width, int value, qboolean
 		else
 			frame = *ptr -'0';
 
-//		R_DrawScaledPic (x, y, HudScale(), scr_hudalpha->value,sb_nums[color][frame]);
+		ds.pic = sb_nums[color][frame];
-//		x += scaledHud(CHAR_WIDTH);
+		ds.x = x;	ds.w = digitWidth;	
-//		R_DrawScaledPic (x, y, getScreenScale(), scr_hudalpha->value, sb_nums[color][frame]);
+		R_DrawPic (ds);
-//		x += scaleForScreen(CHAR_WIDTH);
+	//	R_DrawStretchPic (x, y, digitWidth, scaleForScreen(ICON_HEIGHT), sb_nums[color][frame], scr_hudalpha->value);
-		R_DrawStretchPic (x, y, digitWidth, scaleForScreen(ICON_HEIGHT), sb_nums[color][frame], scr_hudalpha->value);
 		x += digitWidth;
 		ptr++;
 		l--;
@@ -371,7 +401,8 @@ void CL_ExecuteLayoutString (char *s, qboolean isStatusBar)
 			}
 			if (cl.configstrings[cs_images+value])
 			{
-				R_DrawScaledPic (x, y, getScreenScale(), scr_hudalpha->value, cl.configstrings[cs_images+value]);
+			//	R_DrawScaledPic (x, y, getScreenScale(), scr_hudalpha->value, cl.configstrings[cs_images+value]);
+				SCR_DrawLegacyPic (x, y, getScreenScale(), cl.configstrings[cs_images+value], scr_hudalpha->value);
 			}
 			continue;
 		}
@@ -410,7 +441,8 @@ void CL_ExecuteLayoutString (char *s, qboolean isStatusBar)
 
 			if (!ci->icon)
 				ci = &cl.baseclientinfo;
-			R_DrawScaledPic(x, y, getScreenScale(), scr_hudalpha->value,  ci->iconname);
+		//	R_DrawScaledPic (x, y, getScreenScale(), scr_hudalpha->value,  ci->iconname);
+			SCR_DrawLegacyPic (x, y, getScreenScale(), ci->iconname, scr_hudalpha->value);
 			continue;
 		}
 
@@ -487,7 +519,8 @@ void CL_ExecuteLayoutString (char *s, qboolean isStatusBar)
 		if (!strcmp(token, "picn"))
 		{	// draw a pic from a name
 			token = COM_Parse (&s);
-			R_DrawScaledPic (x, y, getScreenScale(), scr_hudalpha->value, token);
+		//	R_DrawScaledPic (x, y, getScreenScale(), scr_hudalpha->value, token);
+			SCR_DrawLegacyPic (x, y, getScreenScale(), token, scr_hudalpha->value);
 			continue;
 		}
 
@@ -878,8 +911,6 @@ void CL_DrawInventory (void)
 	if (top < 0)
 		top = 0;
 
-	//x = (viddef.width-256)/2;
-	//y = (viddef.height-240)/2;
 //	x = viddef.width/2 - SCR_ScaledHud(128);
 //	y = viddef.height/2 - SCR_ScaledHud(120);
 	x = SCREEN_WIDTH/2 - 128;
@@ -891,7 +922,7 @@ void CL_DrawInventory (void)
 //	Hud_DrawString (x, y, S_COLOR_BOLD"hotkey ### item");
 //	Hud_DrawString (x, y+SCR_ScaledHud(8), S_COLOR_BOLD"------ --- ----");
 //	y += SCR_ScaledHud(16);
-	SCR_DrawPic (x, y, 256, 192, ALIGN_CENTER, "inventory", scr_hudalpha->value);
+	SCR_DrawPic (x, y, 256, 192, ALIGN_CENTER, false, "inventory", scr_hudalpha->value);
 	x += 24;
 	y += 20;
 	SCR_DrawString (x, y, 8, ALIGN_CENTER, S_COLOR_WHITE"hotkey ### item", FONT_SCREEN, 255);

client/cl_parse.c

@@ -868,7 +868,6 @@ void CL_ParseFog (void)
 	green = MSG_ReadByte (&net_message);
 	blue = MSG_ReadByte (&net_message);
 
-//	R_SetFogVars (fogenable, model, density, start, end, red, green, blue);
 	V_SetFogInfo (fogenable, model, density, start, end, red, green, blue);
 }
 

client/cl_screen.c

@@ -53,6 +53,10 @@ vrect_t		scr_vrect;		// position of render window on screen
 
 cvar_t		*scr_viewsize;
 cvar_t		*scr_conspeed;
+cvar_t		*scr_conalpha;		// Psychospaz's transparent console
+cvar_t		*scr_newconback;	// whether to use new console background
+cvar_t		*scr_oldconbar;		// whether to draw bottom bar on old console
+//cvar_t		*scr_conheight;	// how far the console drops down
 cvar_t		*scr_letterbox;
 cvar_t		*scr_centertime;
 //cvar_t		*scr_showturtle;	// unused
@@ -92,6 +96,11 @@ cvar_t		*cl_demomessage;
 cvar_t		*cl_hud;				// placeholder cvar
 cvar_t		*cl_hud_variant;		// placeholder cvar
 
+color_t		color_identity = {255, 255, 255, 255};
+vec4_t		vec4_identity = {1.0f, 1.0f, 1.0f, 1.0f};
+vec4_t		stCoord_default = {-1.0f, -1.0f, -1.0f, -1.0f};
+vec4_t		stCoord_tile = {-2.0f, -2.0f, -2.0f, -2.0f};
+
 float		scr_screenScale;
 float		scr_hudScale;
 float		scr_screenAspect;
@@ -620,12 +629,41 @@ SCR_DrawFill
 Coordinates are 640*480 virtual values
 =================
 */
-void SCR_DrawFill (float x, float y, float width, float height, scralign_t align, int red, int green, int blue, int alpha)
+void SCR_DrawFill (float x, float y, float width, float height, scralign_t align, qboolean roundOut, int red, int green, int blue, int alpha)
 {
 	SCR_ScaleCoords (&x, &y, &width, &height, align);
+	if (roundOut) {
+		x = floor(x);	y = floor(y);	width = ceil(width);	height = ceil(height);
+	}
 	R_DrawFill (x, y, width, height, red, green, blue, alpha);
 }
 
+/*
+================
+SCR_DrawBorder
+Draws a solid color border
+Coordinates are 640*480 virtual values
+=================
+*/
+void SCR_DrawBorder (float x, float y, float width, float height, float borderSize, scralign_t align, qboolean roundOut, int red, int green, int blue, int alpha)
+{
+	float	bSize = floor(SCR_ScaledScreen(borderSize));
+	SCR_ScaleCoords (&x, &y, &width, &height, align);
+	if (roundOut) {
+		x = floor(x);	y = floor(y);	width = ceil(width);	height = ceil(height);
+	}
+
+	// top
+	R_DrawFill (x-bSize, y-bSize, width+bSize*2, bSize, red, green, blue, alpha);
+	// bottom
+	R_DrawFill (x-bSize, y+height, width+bSize*2, bSize, red, green, blue, alpha);
+	// left
+	R_DrawFill (x-bSize, y, bSize, height, red, green, blue, alpha);
+	// right
+	R_DrawFill (x+width, y, bSize, height, red, green, blue, alpha);
+}
+
+#if 0
 /*
 ================
 SCR_DrawPic
@@ -637,6 +675,270 @@ void SCR_DrawPic (float x, float y, float width, float height, scralign_t align,
 	SCR_ScaleCoords (&x, &y, &width, &height, align);
 	R_DrawStretchPic (x, y, width, height, pic, alpha);
 }
+#else
+/*
+================
+SCR_DrawPic
+Coordinates are 640*480 virtual values
+=================
+*/
+void SCR_DrawPic (float x, float y, float width, float height, scralign_t align, qboolean roundOut, char *pic, float alpha)
+{
+	vec4_t			outColor;
+	drawStruct_t	ds;
+
+	SCR_ScaleCoords (&x, &y, &width, &height, align);
+	Vector4Set (outColor, 1.0f, 1.0f, 1.0f, alpha);
+	if (roundOut) {
+		x = floor(x);	y = floor(y);	width = ceil(width);	height = ceil(height);
+	}
+
+	memset (&ds, 0, sizeof(drawStruct_t));
+	ds.pic = pic;
+	ds.x = x;	ds.y = y;	ds.w = width;	ds.h = height;
+	Vector2Copy (vec2_origin, ds.offset);
+	Vector4Copy (outColor, ds.color);
+	R_DrawPic (ds);
+}
+#endif
+
+
+/*
+================
+SCR_ScaledPic
+Coordinates are actual values
+=================
+*/
+void SCR_DrawScaledPic (float x, float y, float scale, qboolean centerCoords, qboolean roundOut, char *pic, float alpha)
+{
+	int				w, h;
+	float			width, height;
+	vec4_t			outColor;
+	drawStruct_t	ds;
+
+	Vector4Set (outColor, 1.0f, 1.0f, 1.0f, alpha);
+	R_DrawGetPicSize (&w, &h, pic);
+	width = (float)w * scale;
+	height = (float)h * scale;
+	if (centerCoords) {
+		x -= (width * 0.5f);
+		y -= (height * 0.5f);
+	}
+	if (roundOut) {
+		x = floor(x);	y = floor(y);	width = ceil(width);	height = ceil(height);
+	}
+
+	memset (&ds, 0, sizeof(drawStruct_t));
+	ds.pic = pic;
+	ds.x = x;	ds.y = y;	ds.w = width;	ds.h = height;
+	Vector2Copy (vec2_origin, ds.offset);
+	Vector4Copy (outColor, ds.color);
+	R_DrawPic (ds);
+}
+
+
+/*
+================
+SCR_DrawLegacyPic
+=================
+*/
+void SCR_DrawLegacyPic (float x, float y, float scale, char *pic, float alpha)
+{
+	vec4_t			outColor;
+	vec4_t			stCoords;
+	drawStruct_t	ds;
+
+	Vector4Set (outColor, 1.0f, 1.0f, 1.0f, alpha);
+	Vector4Set (stCoords, -3.0f, scale, 0, 0);
+
+	memset (&ds, 0, sizeof(drawStruct_t));
+	ds.pic = pic;
+	ds.x = x;	ds.y = y;	ds.w = 24;	ds.h = 24;
+	ds.scale[0] = ds.scale[1] = scale;
+	ds.flags |= DSFLAG_SCALED;
+	Vector2Copy (vec2_origin, ds.offset);
+	Vector4Copy (outColor, ds.color);
+	R_DrawPic (ds);
+}
+
+
+/*
+================
+SCR_DrawColoredPic
+Coordinates are 640*480 virtual values
+=================
+*/
+void SCR_DrawColoredPic (float x, float y, float width, float height, scralign_t align, qboolean roundOut, color_t color, char *pic)
+{
+	vec4_t			outColor;
+	drawStruct_t	ds;
+
+	SCR_ScaleCoords (&x, &y, &width, &height, align);
+	Vector4Set (outColor, (float)color[0]*DIV255, (float)color[1]*DIV255, (float)color[2]*DIV255, (float)color[3]*DIV255);
+	if (roundOut) {
+		x = floor(x);	y = floor(y);	width = ceil(width);	height = ceil(height);
+	}
+
+	memset (&ds, 0, sizeof(drawStruct_t));
+	ds.pic = pic;
+	ds.x = x;	ds.y = y;	ds.w = width;	ds.h = height;
+	Vector2Copy (vec2_origin, ds.offset);
+	Vector4Copy (outColor, ds.color);
+	R_DrawPic (ds);
+}
+
+
+/*
+================
+SCR_DrawOffsetPic
+Coordinates are 640*480 virtual values
+=================
+*/
+void SCR_DrawOffsetPic (float x, float y, float width, float height, vec2_t offset, scralign_t align, qboolean roundOut, color_t color, char *pic)
+{
+	vec4_t			outColor;
+	vec2_t			scaledOffset;
+	drawStruct_t	ds;
+
+	Vector2Copy (offset, scaledOffset);
+	SCR_ScaleCoords (&x, &y, &width, &height, align);
+	SCR_ScaleCoords (NULL, NULL, &scaledOffset[0], &scaledOffset[1], align);
+	Vector4Set (outColor, (float)color[0]*DIV255, (float)color[1]*DIV255, (float)color[2]*DIV255, (float)color[3]*DIV255);
+	if (roundOut) {
+		x = floor(x);	y = floor(y);	width = ceil(width);	height = ceil(height);
+	}
+
+	memset (&ds, 0, sizeof(drawStruct_t));
+	ds.pic = pic;
+	ds.x = x;	ds.y = y;	ds.w = width;	ds.h = height;
+	Vector2Copy (scaledOffset, ds.offset);
+	Vector4Copy (outColor, ds.color);
+	R_DrawPic (ds);
+}
+
+
+/*
+================
+SCR_DrawOffsetPicST
+Coordinates are 640*480 virtual values
+=================
+*/
+void SCR_DrawOffsetPicST (float x, float y, float width, float height, vec2_t offset, vec4_t texCorners, scralign_t align, qboolean roundOut, color_t color, char *pic)
+{
+	vec4_t			outColor;
+	vec2_t			scaledOffset;
+	drawStruct_t	ds;
+
+	Vector2Copy (offset, scaledOffset);
+	SCR_ScaleCoords (&x, &y, &width, &height, align);
+	SCR_ScaleCoords (NULL, NULL, &scaledOffset[0], &scaledOffset[1], align);
+	Vector4Set (outColor, (float)color[0]*DIV255, (float)color[1]*DIV255, (float)color[2]*DIV255, (float)color[3]*DIV255);
+	if (roundOut) {
+		x = floor(x);	y = floor(y);	width = ceil(width);	height = ceil(height);
+	}
+
+	memset (&ds, 0, sizeof(drawStruct_t));
+	ds.pic = pic;
+	ds.x = x;	ds.y = y;	ds.w = width;	ds.h = height;
+	ds.flags |= DSFLAG_USESTCOORDS;
+	Vector2Copy (scaledOffset, ds.offset);
+	Vector4Copy (texCorners, ds.stCoords);
+	Vector4Copy (outColor, ds.color);
+	R_DrawPic (ds);
+}
+
+
+/*
+================
+SCR_DrawScrollPic
+Coordinates are 640*480 virtual values
+=================
+*/
+void SCR_DrawScrollPic (float x, float y, float width, float height, vec2_t offset, vec4_t texCorners, vec2_t scroll, scralign_t align, qboolean roundOut, color_t color, char *pic)
+{
+	vec4_t			outColor;
+	vec2_t			scaledOffset;
+	drawStruct_t	ds;
+
+	Vector2Copy (offset, scaledOffset);
+	SCR_ScaleCoords (&x, &y, &width, &height, align);
+	SCR_ScaleCoords (NULL, NULL, &scaledOffset[0], &scaledOffset[1], align);
+	Vector4Set (outColor, (float)color[0]*DIV255, (float)color[1]*DIV255, (float)color[2]*DIV255, (float)color[3]*DIV255);
+	if (roundOut) {
+		x = floor(x);	y = floor(y);	width = ceil(width);	height = ceil(height);
+	}
+
+	memset (&ds, 0, sizeof(drawStruct_t));
+	ds.pic = pic;
+	ds.x = x;	ds.y = y;	ds.w = width;	ds.h = height;
+	ds.flags |= DSFLAG_USESTCOORDS;
+	Vector2Copy (scroll, ds.scroll);
+	Vector2Copy (scaledOffset, ds.offset);
+	Vector4Copy (texCorners, ds.stCoords);
+	Vector4Copy (outColor, ds.color);
+	R_DrawPic (ds);
+}
+
+
+/*
+================
+SCR_DrawMaskedPic
+Coordinates are 640*480 virtual values
+=================
+*/
+void SCR_DrawMaskedPic (float x, float y, float width, float height, vec2_t offset, vec4_t texCorners, vec2_t scroll, scralign_t align, qboolean roundOut, color_t color, char *pic, char *maskPic)
+{
+	vec4_t			outColor;
+	vec2_t			scaledOffset;
+	drawStruct_t	ds;
+
+	Vector2Copy (offset, scaledOffset);
+	SCR_ScaleCoords (&x, &y, &width, &height, align);
+	SCR_ScaleCoords (NULL, NULL, &scaledOffset[0], &scaledOffset[1], align);
+	Vector4Set (outColor, (float)color[0]*DIV255, (float)color[1]*DIV255, (float)color[2]*DIV255, (float)color[3]*DIV255);
+	if (roundOut) {
+		x = floor(x);	y = floor(y);	width = ceil(width);	height = ceil(height);
+	}
+
+	memset (&ds, 0, sizeof(drawStruct_t));
+	ds.pic = pic;
+	ds.maskPic = maskPic;
+	ds.x = x;	ds.y = y;	ds.w = width;	ds.h = height;
+	ds.flags |= DSFLAG_USESTCOORDS|DSFLAG_MASKED;
+	Vector2Copy (scroll, ds.scroll);
+	Vector2Copy (scaledOffset, ds.offset);
+	Vector4Copy (texCorners, ds.stCoords);
+	Vector4Copy (outColor, ds.color);
+	R_DrawPic (ds);
+}
+
+
+/*
+================
+SCR_DrawTiledPic
+Coordinates are 640*480 virtual values
+=================
+*/
+void SCR_DrawTiledPic (float x, float y, float width, float height, scralign_t align, qboolean roundOut, char *pic, float alpha)
+{
+	vec4_t			outColor;
+	drawStruct_t	ds;
+
+	SCR_ScaleCoords (&x, &y, &width, &height, align);
+	Vector4Set (outColor, 1.0f, 1.0f, 1.0f, alpha);
+	if (roundOut) {
+		x = floor(x);	y = floor(y);	width = ceil(width);	height = ceil(height);
+	}
+
+	memset (&ds, 0, sizeof(drawStruct_t));
+	ds.pic = pic;
+	ds.x = x;	ds.y = y;	ds.w = width;	ds.h = height;
+	ds.flags |= DSFLAG_TILED;
+	Vector2Copy (vec2_origin, ds.offset);
+	Vector4Copy (outColor, ds.color);
+	R_DrawPic (ds);
+}
+
 
 /*
 ================
@@ -652,6 +954,7 @@ void SCR_DrawChar (float x, float y, int size, scralign_t align, int num, fontsl
 	R_DrawChar(x, y, num, font, scale, red, green, blue, alpha, italic, last);
 }
 
+
 /*
 ================
 SCR_DrawString
@@ -1360,6 +1663,13 @@ void SCR_Init (void)
 	Cvar_SetDescription ("viewsize", "Draw size of screen in percent, from 40 to 100.");
 	scr_conspeed = Cvar_Get ("scr_conspeed", "3", 0);
 	Cvar_SetDescription ("scr_conspeed", "Scrolling speed of the console.");
+	scr_conalpha = Cvar_Get ("scr_conalpha", "0.5", CVAR_ARCHIVE);		// Psychospaz's transparent console
+	Cvar_SetDescription ("scr_conalpha", "Opacity of console background.");
+	scr_newconback = Cvar_Get ("scr_newconback", "0", CVAR_ARCHIVE);	// whether to use new console background
+	Cvar_SetDescription ("scr_newconback", "Toggles use of new console background.");
+	scr_oldconbar = Cvar_Get ("scr_oldconbar", "1", CVAR_ARCHIVE);		// whether to draw bottom bar on old console
+	Cvar_SetDescription ("scr_oldconbar", "Toggles drawing of solid color bottom bar on console with standard conback image.");
+//	scr_conheight = Cvar_Get ("scr_conheight", "0.5", CVAR_ARCHIVE);	// how far the console drops down
 	scr_letterbox = Cvar_Get ("scr_letterbox", "1", CVAR_ARCHIVE);
 	Cvar_SetDescription ("scr_letterbox", "Enables letterbox effect for cameras and cutscenes.");
 //	scr_showturtle = Cvar_Get ("scr_showturtle", "0", 0);	// unused
@@ -1505,7 +1815,7 @@ void SCR_DrawCrosshair (void)
 //					scr_vrect.y + (int)(((float)scr_vrect.height - scale*(float)crosshair_height)*0.5),	// y
 //					scale, alpha, crosshair_pic);
 	SCR_DrawPic ( ((float)SCREEN_WIDTH - scaledSize)*0.5, ((float)SCREEN_HEIGHT - scaledSize)*0.5,
-					scaledSize, scaledSize, ALIGN_CENTER, crosshair_pic, alpha);
+					scaledSize, scaledSize, ALIGN_CENTER, false, crosshair_pic, alpha);
 }
 
 
@@ -1520,7 +1830,8 @@ void SCR_DrawNet (void)
 		< CMD_BACKUP-1)
 		return;
 
-	R_DrawPic (scr_vrect.x + SCR_ScaledHud(64), scr_vrect.y, "net");
+//	R_DrawPic (scr_vrect.x + SCR_ScaledHud(64), scr_vrect.y, "net");
+	SCR_DrawPic (scr_vrect.x+64, scr_vrect.y, 32, 32, ALIGN_TOPLEFT, false, "net", 1.0f);
 }
 
 
@@ -1548,10 +1859,10 @@ void SCR_DrawAlertMessagePicture (char *name, qboolean center, int yOffset)
 
 	if (center)
 		SCR_DrawPic((SCREEN_WIDTH - w)*0.5, (SCREEN_HEIGHT - h)*0.5,
-				w, h, ALIGN_CENTER, name, 1.0);
+				w, h, ALIGN_CENTER, false, name, 1.0);
 	else
 		SCR_DrawPic((SCREEN_WIDTH - w)*0.5, SCREEN_HEIGHT*0.5 + yOffset,
-				w, h, ALIGN_CENTER, name, 1.0);
+				w, h, ALIGN_CENTER, false, name, 1.0);
 }
 
 
@@ -1562,13 +1873,16 @@ SCR_DrawPause
 */
 void SCR_DrawPause (void)
 {
-	int		w, h;
+	int		w, h, x, y;
+
+	w = 129;	// size of original pause.pcx = 101x25
+	h = 32;
+	x = (SCREEN_WIDTH - w)*0.5;
+	y = (SCREEN_HEIGHT - h)*0.5;
 
-//	if (!scr_showpause->value)		// turn off for screenshots
 	if (!scr_showpause->integer)		// turn off for screenshots
 		return;
 
-//	if (!cl_paused->value)
 	if (!cl_paused->integer)
 		return;
 
@@ -1576,8 +1890,9 @@ void SCR_DrawPause (void)
 	if (cls.key_dest == key_menu)
 		return;
 
-	R_DrawGetPicSize (&w, &h, "pause");
+//	R_DrawGetPicSize (&w, &h, "pause");
-	SCR_DrawPic ((SCREEN_WIDTH-w)*0.5, (SCREEN_HEIGHT-h)*0.5, w, h, ALIGN_CENTER, "pause", 1.0);
+//	SCR_DrawPic ((SCREEN_WIDTH-w)*0.5, (SCREEN_HEIGHT-h)*0.5, w, h, ALIGN_CENTER, "pause", 1.0);
+	SCR_DrawPic (x, y, w, h, ALIGN_CENTER, false, "pause", 1.0);
 }
 
 
@@ -1598,11 +1913,11 @@ void SCR_DrawLoadingTagProgress (char *picName, int yOffset, int percent)
 	y = (SCREEN_HEIGHT - h)*0.5;
 	barPos = min(max(percent, 0), 100) / 4;
 
-	SCR_DrawPic (x, y + yOffset, w, h, ALIGN_CENTER, picName, 1.0);
+	SCR_DrawPic (x, y + yOffset, w, h, ALIGN_CENTER, false, picName, 1.0);
 
 	for (i=0; i<barPos; i++)
 		SCR_DrawPic (x + 33 + (i * LOADBAR_TIC_SIZE_X), y + 28 + yOffset, LOADBAR_TIC_SIZE_X, LOADBAR_TIC_SIZE_Y,
-					ALIGN_CENTER, "loading_led1", 1.0);
+					ALIGN_CENTER, false, "loading_led1", 1.0);
 }
 
 
@@ -1622,11 +1937,11 @@ void SCR_DrawLoadingBar (float x, float y, float w, float h, int percent, float
 	iRatio = 1 - fabs(sizeRatio);
 	hiRatio = iRatio * 0.5;
 
-	SCR_DrawFill (x, y, w, h, ALIGN_STRETCH, 255, 255, 255, 90);
+	SCR_DrawFill (x, y, w, h, ALIGN_STRETCH, false, 255, 255, 255, 90);
 
 	if (percent != 0)
 		SCR_DrawFill (x+(h*hiRatio), y+(h*hiRatio), (w-(h*iRatio))*percent*0.01, h*sizeRatio,
-						ALIGN_STRETCH, red, green, blue, 255);
+						ALIGN_STRETCH, false, red, green, blue, 255);
 }
 
 
@@ -1687,48 +2002,48 @@ void SCR_DrawLoading (void)
 
 		// show saveshot here
 		if (load_saveshot && (strlen(load_saveshot) > 8) && R_DrawFindPic(load_saveshot)) {
-			SCR_DrawPic (0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_STRETCH, load_saveshot, 1.0);
+			SCR_DrawPic (0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_STRETCH, false, load_saveshot, 1.0);
 			haveMapPic = true;
 		}
 		// else try levelshot
 		else if (/*widescreen &&*/ R_DrawFindPic(va("/levelshots/%s_widescreen.pcx", mapfile)))
 		{
 			// Draw at 16:10 aspect, don't stretch to 16:9 or wider
-			SCR_DrawFill (0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_STRETCH_ALL, 0, 0, 0, 255);
+			SCR_DrawFill (0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_STRETCH_ALL, false, 0, 0, 0, 255);
 		//	SCR_DrawPic (-64, 0, SCREEN_WIDTH+128, SCREEN_HEIGHT, ALIGN_CENTER, va("/levelshots/%s_widescreen.pcx", mapfile), 1.0);
 			// Draw at native aspect
 			Com_sprintf(picName, sizeof(picName), "/levelshots/%s_widescreen.pcx", mapfile);
 			SCR_GetPicPosWidth (picName, &picX, &picW);
-			SCR_DrawPic (picX, 0, picW, SCREEN_HEIGHT, ALIGN_CENTER, picName, 1.0);
+			SCR_DrawPic (picX, 0, picW, SCREEN_HEIGHT, ALIGN_CENTER, false, picName, 1.0);
 			haveMapPic = true;
 		}
 		else if (R_DrawFindPic(va("/levelshots/%s.pcx", mapfile))) {
 			// Draw at 4:3 aspect, don't stretch to 16:9 or wider
-			SCR_DrawFill (0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_STRETCH_ALL, 0, 0, 0, 255);
+			SCR_DrawFill (0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_STRETCH_ALL, false, 0, 0, 0, 255);
-			SCR_DrawPic (0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_CENTER, va("/levelshots/%s.pcx", mapfile), 1.0); // was ALIGN_STRETCH
+			SCR_DrawPic (0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_CENTER, false, va("/levelshots/%s.pcx", mapfile), 1.0); // was ALIGN_STRETCH
 			haveMapPic = true;
 		}
 		// else fall back on loadscreen
 		else if (R_DrawFindPic(LOADSCREEN_NAME)) {
-			SCR_DrawFill (0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_STRETCH_ALL, 0, 0, 0, 255);
+			SCR_DrawFill (0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_STRETCH_ALL, false, 0, 0, 0, 255);
 		//	SCR_DrawPic (0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_STRETCH, LOADSCREEN_NAME, 1.0);
 			SCR_GetPicPosWidth (LOADSCREEN_NAME, &picX, &picW);
-			SCR_DrawPic (picX, 0, picW, SCREEN_HEIGHT, ALIGN_CENTER, LOADSCREEN_NAME, 1.0);
+			SCR_DrawPic (picX, 0, picW, SCREEN_HEIGHT, ALIGN_CENTER, false, LOADSCREEN_NAME, 1.0);
 		}
 		// else draw black screen
 		else
-			SCR_DrawFill (0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_STRETCH_ALL, 0, 0, 0, 255);
+			SCR_DrawFill (0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_STRETCH_ALL, false, 0, 0, 0, 255);
 
 		isMap = true;
 	}
 	else if (R_DrawFindPic(LOADSCREEN_NAME)) {
-		SCR_DrawFill (0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_STRETCH_ALL, 0, 0, 0, 255);
+		SCR_DrawFill (0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_STRETCH_ALL, false, 0, 0, 0, 255);
 	//	SCR_DrawPic (0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_STRETCH, LOADSCREEN_NAME, 1.0);
 		SCR_GetPicPosWidth (LOADSCREEN_NAME, &picX, &picW);
-		SCR_DrawPic (picX, 0, picW, SCREEN_HEIGHT, ALIGN_CENTER, LOADSCREEN_NAME, 1.0);
+		SCR_DrawPic (picX, 0, picW, SCREEN_HEIGHT, ALIGN_CENTER, false, LOADSCREEN_NAME, 1.0);
 	}
 	else
-		SCR_DrawFill (0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_STRETCH_ALL, 0, 0, 0, 255);
+		SCR_DrawFill (0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_STRETCH_ALL, false, 0, 0, 0, 255);
 
 	// Add Download info stuff...
 #ifdef USE_CURL	// HTTP downloading from R1Q2
@@ -1901,12 +2216,12 @@ Scroll it up or down
 void SCR_RunConsole (void)
 {
 	// Knightmare- clamp console height
-	//if (con_height->value < 0.1f || con_height->value > 1.0f)
+	//if (scr_conheight->value < 0.1f || con_height->value > 1.0f)
-	//	Cvar_SetValue( "con_height", ClampCvar( 0.1, 1, con_height->value ) );
+	//	Cvar_SetValue( "scr_conheight", ClampCvar( 0.1, 1, scr_conheight->value ) );
 
 	// decide on the height of the console
 	if (cls.consoleActive) // (cls.key_dest == key_console)
-		//scr_conlines = halfconback?0.5:con_height->value; // variable height console
+		//scr_conlines = halfconback ? 0.5 : scr_conheight->value; // variable height console
 		scr_conlines = 0.5;
 	else
 		scr_conlines = 0;				// none visible
@@ -2106,10 +2421,10 @@ void SCR_TileClear (void)
 {
 	int		top, bottom, left, right;
 	int		w, h;
+	drawStruct_t	ds;
 
 	if (scr_con_current == 1.0)
 		return;		// full screen console
-//	if (scr_viewsize->value == 100)
 	if (scr_viewsize->integer == 100)
 		return;		// full screen rendering
 	if (cl.cinematictime > 0)
@@ -2123,17 +2438,31 @@ void SCR_TileClear (void)
 	left = cl.refdef.x;
 	right = left + cl.refdef.width-1;
 
+	memset (&ds, 0, sizeof(drawStruct_t));
+	ds.pic = "backtile";
+	ds.flags |= DSFLAG_TILED;
+	Vector2Copy (vec2_origin, ds.offset);
+	Vector4Copy (vec4_identity, ds.color);
+
 	// clear above view screen
-	R_DrawTileClear (0, 0, w, top, "backtile");
+	ds.x = 0;	ds.y = 0;		ds.w = w;		ds.h = top;
+	R_DrawPic (ds);
+//	R_DrawTileClear (0, 0, w, top, "backtile");
 
 	// clear below view screen
-	R_DrawTileClear (0, bottom, w, h - bottom, "backtile");
+	ds.x = 0;	ds.y = bottom;	ds.w = w;		ds.h = h - bottom;
+	R_DrawPic (ds);
+//	R_DrawTileClear (0, bottom, w, h - bottom, "backtile");
 
 	// clear left of view screen
-	R_DrawTileClear (0, top, left, bottom - top + 1, "backtile");
+	ds.x = 0;	ds.y = top;		ds.w = left;	ds.h = bottom - top + 1;
+	R_DrawPic (ds);
+//	R_DrawTileClear (0, top, left, bottom - top + 1, "backtile");
 
 	// clear right of view screen
-	R_DrawTileClear (right, top, w - right, bottom - top + 1, "backtile");
+	ds.x = right;	ds.y = top;	ds.w = w - right;	ds.h = bottom - top + 1;
+	R_DrawPic (ds);
+//	R_DrawTileClear (right, top, w - right, bottom - top + 1, "backtile");
 }
 
 
@@ -2180,8 +2509,8 @@ void DrawDemoMessage (void)
 		char *message = "Running Demo";
 		len = (int)strlen(message);
 
-		SCR_DrawFill (0, SCREEN_HEIGHT-(MENU_FONT_SIZE+3), SCREEN_WIDTH, MENU_FONT_SIZE+4, ALIGN_BOTTOM_STRETCH, 60, 60, 60, 255);	// go 1 pixel past screen bottom to prevent gap from scaling
+		SCR_DrawFill (0, SCREEN_HEIGHT-(MENU_FONT_SIZE+3), SCREEN_WIDTH, MENU_FONT_SIZE+4, ALIGN_BOTTOM_STRETCH, false, 60, 60, 60, 255);	// go 1 pixel past screen bottom to prevent gap from scaling
-		SCR_DrawFill (0, SCREEN_HEIGHT-(MENU_FONT_SIZE+3), SCREEN_WIDTH, 1, ALIGN_BOTTOM_STRETCH, 0, 0, 0, 255);
+		SCR_DrawFill (0, SCREEN_HEIGHT-(MENU_FONT_SIZE+3), SCREEN_WIDTH, 1, ALIGN_BOTTOM_STRETCH, false, 0, 0, 0, 255);
 		SCR_DrawString (SCREEN_WIDTH/2-(len/2)*MENU_FONT_SIZE, SCREEN_HEIGHT-(MENU_FONT_SIZE+1), MENU_FONT_SIZE, ALIGN_BOTTOM, message, FONT_SCREEN, 255);
 	}
 }

client/cl_string.c

@@ -197,3 +197,127 @@ void CL_DrawStringGeneric (int x, int y, const char *string, fontslot_t font, in
 			character, font, textScale, red, green, blue, alpha, italic, flushChar );
 	}
 }
+
+
+/*
+================
+CL_DrawStringFromCharsPic
+================
+*/
+void CL_DrawStringFromCharsPic (float x, float y, float w, float h, vec2_t offset, float width, char *string, color_t color, char *pic, int flags)
+{
+	vec4_t			modulate, shadowModulate, texCorners;
+	char			line[1024], *l;
+	int				len, ch;
+	float			xx, yy, ofsX, ofsY, col, row;
+	char			modifier;
+	int				red, green, blue, italic, shadow, bold, reset;
+	qboolean		modified;
+	drawStruct_t	ds;
+
+	memset (&ds, 0, sizeof(drawStruct_t));
+	Vector4Set (modulate, (float)color[0] * DIV255, (float)color[1] * DIV255, (float)color[2] * DIV255, (float)color[3] * DIV255);
+	Vector4Set (shadowModulate, 0, 0, 0, modulate[3]);
+	ofsX = w * 0.125;
+	ofsY = h * 0.125;
+
+	yy = y;
+	while (*string)
+	{
+		// Get a line of text
+		len = 0;
+		while (*string)
+		{
+			if (*string == '\n') {
+				string++;
+				break;
+			}
+			line[len++] = *string++;
+
+			if (len == sizeof(line)-1)
+				break;
+		}
+		line[len] = 0;
+
+		// Align the text as appropriate
+		if (flags & DSF_LEFT)
+			xx = x;
+		else if (flags & DSF_CENTER)
+			xx = x + ((width - (stringLen(line) * w)) / 2);
+		else if (flags & DSF_RIGHT)
+			xx = x + (width - (stringLen(line) * w));
+		else	// default
+			xx = x;
+
+		// Convert to lower/upper case if needed
+		if (flags & DSF_LOWERCASE)
+			Q_strlwr(line);
+		if (flags & DSF_UPPERCASE)
+			Q_strupr(line);
+
+		// Draw it
+		l = line;
+		while (*l)
+		{
+		/*	if (Q_IsColorString(l))
+			{
+				if (!(flags & DSF_FORCECOLOR)) {
+				//	*(unsigned *)modulate = *(unsigned *)colorTable[Q_ColorIndex(*(l+1))];
+					modulate[3] = (float)color[3] * DIV255;
+				}
+				l += 2;
+				continue;
+			}*/
+			modifier = l[0];
+			if (modifier & 128) modifier &= ~128;
+			if (modifier == '^' && *(l+1) != 0)
+			{
+				reset = 0;
+				modifier = l[1];
+				if (modifier & 128) modifier &= ~128;
+				if (modifier != '^')
+				{
+					modified = CL_StringSetParams(modifier, &red, &green, &blue, &bold, &shadow, &italic, &reset);
+					if (reset)
+						red = green = blue = 255;
+					if (modified) {
+						Vector4Set (modulate, (float)red*DIV255, (float)green*DIV255, (float)blue*DIV255, modulate[3]);
+						l += 2;
+						continue;
+					}
+				}
+			}
+
+			ch = *l++;
+			ch &= 255;
+			ch &= ~128;
+			if (ch != ' ')
+			{
+				col = (ch & 15) * 0.0625;
+				row = (ch >> 4) * 0.0625;
+				Vector4Set (texCorners, col, row, col + 0.0625, row + 0.0625);
+
+				ds.pic = pic;
+				ds.w = w;	ds.h = h;
+				ds.flags |= DSFLAG_USESTCOORDS;
+				Vector2Copy (offset, ds.offset);
+				Vector4Copy (texCorners, ds.stCoords);
+
+				if (flags & DSF_DROPSHADOW || shadow)
+				{
+					ds.x = xx + ofsX;	ds.y = yy + ofsY;
+					Vector4Copy (shadowModulate, ds.color);
+					R_DrawPic (ds);
+				//	R_DrawPic (xx + ofsX, yy + ofsY, w, h, offset, texCorners, shadowModulate, pic);
+				}
+
+				ds.x = xx;	ds.y = yy;
+				Vector4Copy (modulate, ds.color);
+				R_DrawPic (ds);
+			//	R_DrawPic (xx, yy, w, h, offset, texCorners, modulate, pic);
+			}
+			xx += w;
+		}
+		yy += h;
+	}
+}

client/client.h

@@ -412,11 +412,10 @@ extern	cvar_t	*cl_particle_scale;
 // whether to adjust fov for wide aspect rattio
 extern	cvar_t	*cl_widescreen_fov;
 
-
+extern	cvar_t	*scr_conalpha;		// Psychospaz's transparent console
-extern	cvar_t	*con_alpha; // Psychospaz's transparent console
+extern	cvar_t	*scr_newconback;	// whether to use new console background
-//extern	cvar_t	*con_height; // how far the console drops down
+extern	cvar_t	*scr_oldconbar;		// whether to draw bottom bar on old console
-extern	cvar_t	*con_newconback;	// whether to use new console background
+//extern	cvar_t	*scr_conheight; // how far the console drops down
-extern	cvar_t	*con_oldconbar;		// whether to draw bottom bar on old console
 
 // Psychospaz's chasecam
 extern	cvar_t	*cg_thirdperson;
@@ -565,6 +564,7 @@ extern	sizebuf_t	net_message;
 qboolean CL_StringSetParams (char modifier, int *red, int *green, int *blue, int *bold, int *shadow, int *italic, int *reset);
 void Con_DrawString (int x, int y, char *s, fontslot_t font, int alpha);
 void CL_DrawStringGeneric (int x, int y, const char *string, fontslot_t font, int alpha, int fontSize, textscaletype_t scaleType, qboolean altBit);
+void CL_DrawStringFromCharsPic (float x, float y, float w, float h, vec2_t offset, float width, char *string, color_t color, char *pic, int flags);
 
 // cl_scrn.c
 typedef struct
@@ -767,18 +767,23 @@ void	R_RenderFrame (refdef_t *fd);
 
 void	R_SetParticlePicture (int num, char *name); // Knightmare added
 
-void	R_DrawGetPicSize (int *w, int *h, char *name);	// will return 0 0 if not found
-void	R_DrawPic (int x, int y, char *name);
-// added alpha for Psychospaz's transparent console
-void	R_DrawStretchPic (int x, int y, int w, int h, char *name, float alpha);
-void	R_DrawScaledPic (int x, int y, float scale, float alpha, char *name);
-// added char scaling from Quake2Max
 void	R_DrawChar (float x, float y, int c, fontslot_t font, float scale,
 					int red, int green, int blue, int alpha, qboolean italic, qboolean last);
 void	R_DrawString (float x, float y, const char *string, fontslot_t font, float scale, 
-				int red, int green, int blue, int alpha, qboolean italic, qboolean shadow);
+					int red, int green, int blue, int alpha, qboolean italic, qboolean shadow);
-void	R_DrawTileClear (int x, int y, int w, int h, char *name);
+
+void	R_DrawGetPicSize (int *w, int *h, char *name);	// will return 0 0 if not found
+
+void	R_DrawPic (drawStruct_t ds);
+
+//void	R_DrawPic (int x, int y, char *name);
+// added alpha for Psychospaz's transparent console
+//void	R_DrawStretchPic (int x, int y, int w, int h, char *name, float alpha);
+//void	R_DrawScaledPic (int x, int y, float scale, float alpha, char *name);
+//void	R_DrawTileClear (int x, int y, int w, int h, char *name);
+
 void	R_DrawFill (int x, int y, int w, int h, int red, int green, int blue, int alpha);
+
 void	R_DrawCameraEffect (void);
 
 void	R_GrabScreen (void); // screenshots for savegames
@@ -786,8 +791,6 @@ void	R_ScaledScreenshot (char *name); //  screenshots for savegames
 
 int		R_MarkFragments (const vec3_t origin, const vec3_t axis[3], float radius, int maxPoints, vec3_t *points, int maxFragments, markFragment_t *fragments);
 
-//void	R_SetFogVars (qboolean enable, int model, int density, int start, int end, int red, int green, int blue);
-
 float	R_CharMapScale (void); // Knightmare added char scaling from Quake2Max
 
 // Draw images for cinematic rendering (which can have a different palette). Note that calls

client/ref.h

@@ -75,6 +75,27 @@ typedef enum
 	FONT_UI
 } fontslot_t;
 
+#define DSFLAG_USESTCOORDS		0x0001		// use passed st coords instead of texture's st coords
+#define DSFLAG_TILED			0x0002		// tile image instead of stretching
+#define DSFLAG_SCALED			0x0004		// scale up using scale values, instead of width and height
+#define DSFLAG_CLAMP			0x0004		// texture edge clamping
+#define DSFLAG_MASKED			0x0008		// use mask image
+
+typedef struct
+{
+	int			x;
+	int			y;
+	int			w;
+	int			h;
+	vec2_t		scroll;
+	vec2_t		scale;
+	vec2_t		offset;
+	vec4_t		stCoords;
+	vec4_t		color;
+	char		*pic;
+	char		*maskPic;
+	unsigned	flags;
+} drawStruct_t;
 
 typedef struct entity_s
 {

client/screen.h

@@ -22,18 +22,9 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 // screen.h
 
-typedef struct
-{
-	float x;
-	float y;
-	float min;
-} screenscale_t;
-
-//screenscale_t screenScale;
-
-
 typedef enum
 {
+	ALIGN_UNSET = 0,
 	ALIGN_STRETCH,
 	ALIGN_STRETCH_ALL,
 	ALIGN_CENTER,
@@ -52,15 +43,52 @@ typedef enum
 
 typedef enum
 {
-SCALETYPE_CONSOLE,
+	SCALETYPE_CONSOLE,
-SCALETYPE_HUD,
+	SCALETYPE_HUD,
-SCALETYPE_MENU
+	SCALETYPE_MENU
 } textscaletype_t;
 
+typedef struct
+{
+	float x;
+	float y;
+	float min;
+} screenscale_t;
+
 #define	STAT_MINUS		10	// num frame for '-' stats digit
 #define CHAR_WIDTH		16
 
 
+// flags for hud drawing items
+#define DSF_FORCECOLOR			1
+#define DSF_DROPSHADOW			2
+#define DSF_LEFT				4
+#define DSF_CENTER				8
+#define DSF_RIGHT				16
+#define DSF_LOWERCASE			32
+#define DSF_UPPERCASE			64
+#define	DSF_FLIPX				128
+#define	DSF_FLIPY				256
+#define DSF_OVERRIDEPATH		512
+#define	DSF_RENAMESHADER		1024
+#define	DSF_MASKSHADER			2048	// uses shaderMinus for mask image
+
+
+// Psychospaz's scaled menu stuff
+#define SCREEN_WIDTH	640.0f
+#define SCREEN_HEIGHT	480.0f
+#define STANDARD_ASPECT_RATIO ((float)SCREEN_WIDTH/(float)SCREEN_HEIGHT)
+
+// rendered size of console font - everthing adjusts to this...
+#define	FONT_SIZE		SCR_ScaledScreen(con_font_size->value)
+#define CON_FONT_SCALE	SCR_ScaledScreen(con_font_size->value)/8.0f
+
+#define MENU_FONT_SIZE	8
+#define MENU_LINE_SIZE	10
+
+#define HUD_FONT_SIZE	8.0
+
+
 extern	char		*sb_nums[2][11];
 
 extern	float		scr_con_current;
@@ -81,23 +109,14 @@ extern	cvar_t		*crosshair_pulse;
 
 extern	vrect_t		scr_vrect;		// position of render window
 
+extern color_t		color_identity;
+extern vec4_t		vec4_identity;
+extern vec4_t		stCoord_default;
+extern vec4_t		stCoord_tile;
+
 extern	char		crosshair_pic[MAX_QPATH];
 extern	int			crosshair_width, crosshair_height;
 
-// Psychospaz's scaled menu stuff
-#define SCREEN_WIDTH	640.0f
-#define SCREEN_HEIGHT	480.0f
-#define STANDARD_ASPECT_RATIO ((float)SCREEN_WIDTH/(float)SCREEN_HEIGHT)
-
-// rendered size of console font - everthing adjusts to this...
-#define	FONT_SIZE		SCR_ScaledScreen(con_font_size->value)
-#define CON_FONT_SCALE	SCR_ScaledScreen(con_font_size->value)/8.0f
-
-#define MENU_FONT_SIZE	8
-#define MENU_LINE_SIZE	10
-
-#define HUD_FONT_SIZE	8.0
-
 //
 // cl_screen.c
 //
@@ -123,8 +142,18 @@ void	SCR_ScaleCoords (float *x, float *y, float *w, float *h, scralign_t align);
 float	SCR_ScaledScreen (float param);
 float	SCR_GetScreenScale (void);
 
-void	SCR_DrawFill (float x, float y, float width, float height, scralign_t align, int red, int green, int blue, int alpha);
+void	SCR_DrawFill (float x, float y, float width, float height, scralign_t align, qboolean roundOut, int red, int green, int blue, int alpha);
-void	SCR_DrawPic (float x, float y, float width, float height, scralign_t align, char *pic, float alpha);
+void	SCR_DrawBorder (float x, float y, float width, float height, float borderSize, scralign_t align, qboolean roundOut, int red, int green, int blue, int alpha);
+//void	SCR_DrawPic (float x, float y, float width, float height, scralign_t align, char *pic, float alpha);
+void	SCR_DrawPic (float x, float y, float width, float height, scralign_t align, qboolean roundOut, char *pic, float alpha);
+void	SCR_DrawScaledPic (float x, float y, float scale, qboolean centerCoords, qboolean roundOut, char *pic, float alpha);
+void	SCR_DrawLegacyPic (float x, float y, float scale, char *pic, float alpha);
+void	SCR_DrawColoredPic (float x, float y, float width, float height, scralign_t align, qboolean roundOut, color_t color, char *pic);
+void	SCR_DrawOffsetPic (float x, float y, float width, float height, vec2_t offset, scralign_t align, qboolean roundOut, color_t color, char *pic);
+void	SCR_DrawOffsetPicST (float x, float y, float width, float height, vec2_t offset, vec4_t texCorners, scralign_t align, qboolean roundOut, color_t color, char *pic);
+void	SCR_DrawScrollPic (float x, float y, float width, float height, vec2_t offset, vec4_t texCorners, vec2_t scroll, scralign_t align, qboolean roundOut, color_t color, char *pic);
+void	SCR_DrawMaskedPic (float x, float y, float width, float height, vec2_t offset, vec4_t texCorners, vec2_t scroll, scralign_t align, qboolean roundOut, color_t color, char *pic, char *maskPic);
+void	SCR_DrawTiledPic (float x, float y, float width, float height, scralign_t align, qboolean roundOut, char *pic, float alpha);
 void	SCR_DrawChar (float x, float y, int size, scralign_t align, int num, fontslot_t font, int red, int green, int blue, int alpha, qboolean italic, qboolean last);
 void	SCR_DrawString (float x, float y, int size, scralign_t align, const char *string, fontslot_t font, int alpha);
 void	SCR_DrawCrosshair (void);

client/snd_dma.c

@@ -892,6 +892,7 @@ void S_AddLoopSounds (void)
 	sfxcache_t	*sc;
 	int			num;
 	float		dist_mult;
+	vec3_t		origin_v;	// Knightmare added
 	entity_state_t	*ent;
 
 	if (cl_paused->value)
@@ -941,56 +942,42 @@ void S_AddLoopSounds (void)
 		if (ent->solid == 31) // special value for bmodels
 		{
 			cmodel_t	*cmodel;
-			vec3_t		origin_v;
+			qboolean	outofbounds = false;
 			int			k;
 
 			cmodel = cl.model_clip[ent->modelindex];
 			if (cmodel) {
 				for (k=0; k<3; k++)
-					origin_v[k] = ent->origin[k]+0.5*(cmodel->mins[k]+cmodel->maxs[k]);
+					if (ent->origin[k] < cmodel->mins[k] || ent->origin[k] > cmodel->maxs[k])
+						outofbounds = true;
+			}
+			if (cmodel && outofbounds) {
+				for (k=0; k<3; k++)
+					origin_v[k] = ent->origin[k] + 0.5 * (cmodel->mins[k] + cmodel->maxs[k]);
 			}
 			else
 				VectorCopy (ent->origin, origin_v);
-
-			// find the total contribution of all sounds of this type
-			S_SpatializeOrigin (origin_v, 255.0, dist_mult, //SOUND_LOOPATTENUATE, // was ent->origin
-				&left_total, &right_total);
-			for (j=i+1 ; j<cl.frame.num_entities ; j++)
-			{
-				if (sounds[j] != sounds[i])
-					continue;
-				sounds[j] = 0;	// don't check this again later
-
-				num = (cl.frame.parse_entities + j)&(MAX_PARSE_ENTITIES-1);
-				ent = &cl_parse_entities[num];
-
-				S_SpatializeOrigin (origin_v, 255.0, dist_mult, //SOUND_LOOPATTENUATE, // was ent->origin
-					&left, &right);
-				left_total += left;
-				right_total += right;
-			}
 		}
-		else // somebody please tell me why this has to stay unchanged to work (pointer to ent->origin won't work)
+		else
+			VectorCopy (ent->origin, origin_v);
+
+		// find the total contribution of all sounds of this type
+		S_SpatializeOrigin (origin_v, 255.0, dist_mult, // SOUND_LOOPATTENUATE // was ent->origin
+			&left_total, &right_total);
+		for (j=i+1; j<cl.frame.num_entities; j++)
 		{
-			// find the total contribution of all sounds of this type
+			if (sounds[j] != sounds[i])
-			S_SpatializeOrigin (ent->origin, 255.0, dist_mult, //SOUND_LOOPATTENUATE, // was ent->origin
+				continue;
-				&left_total, &right_total);
+			sounds[j] = 0;	// don't check this again later
-			for (j=i+1 ; j<cl.frame.num_entities ; j++)
-			{
-				if (sounds[j] != sounds[i])
-					continue;
-				sounds[j] = 0;	// don't check this again later
 
-				num = (cl.frame.parse_entities + j)&(MAX_PARSE_ENTITIES-1);
+			num = (cl.frame.parse_entities + j)&(MAX_PARSE_ENTITIES-1);
-				ent = &cl_parse_entities[num];
+			ent = &cl_parse_entities[num];
 
-				S_SpatializeOrigin (ent->origin, 255.0, dist_mult, //SOUND_LOOPATTENUATE, // was ent->origin
+			S_SpatializeOrigin (origin_v, 255.0, dist_mult, // SOUND_LOOPATTENUATE // was ent->origin
-					&left, &right);
+				&left, &right);
-				left_total += left;
+			left_total += left;
-				right_total += right;
+			right_total += right;
-			}
 		}
-		// end Knightmare
 
 		if (left_total == 0 && right_total == 0)
 			continue;		// not audible

game/g_ai.c

@@ -146,7 +146,7 @@ void ai_stand (edict_t *self, float dist)
 			self->monsterinfo.aiflags &= ~(AI_CHICKEN | AI_STAND_GROUND);
 			self->monsterinfo.pausetime = 0;
 			if (self->enemy)
-				FoundTarget(self);
+				FoundTarget (self);
 		}
 	}
 
@@ -208,9 +208,9 @@ void ai_stand (edict_t *self, float dist)
 	{
 		// Lazarus: Solve problem of monsters pausing at path_corners, taking off in 
 		//          original direction
-		if(self->enemy && self->enemy->inuse)
+		if (self->enemy && self->enemy->inuse)
 			VectorSubtract (self->enemy->s.origin, self->s.origin, v);
-		else if(self->goalentity)
+		else if (self->goalentity)
 			VectorSubtract (self->goalentity->s.origin, self->s.origin, v);
 		else {
 			self->monsterinfo.pausetime = level.time + random() * 15;
@@ -226,7 +226,7 @@ void ai_stand (edict_t *self, float dist)
 			R = realrange(self,self->movetarget);
 			if (R > ACTOR_FOLLOW_RUN_RANGE)
 				self->monsterinfo.run (self);
-			else if(R > ACTOR_FOLLOW_STAND_RANGE || !self->movetarget->client)
+			else if (R > ACTOR_FOLLOW_STAND_RANGE || !self->movetarget->client)
 				self->monsterinfo.walk (self);
 		}
 		else
@@ -298,7 +298,7 @@ void ai_charge (edict_t *self, float dist)
 	// This is normally not necessary, but target_anger making 
 	// monster mad at a static object (a pickup, for example)
 	// previously resulted in weirdness here
-	if(!self->enemy || !self->enemy->inuse)
+	if (!self->enemy || !self->enemy->inuse)
 		return;
 
 	VectorSubtract (self->enemy->s.origin, self->s.origin, v);
@@ -552,19 +552,19 @@ void FoundTarget (edict_t *self)
 		level.sight_entity->light_level = 128;
 
 		goodguy = NULL;
-		goodguy = G_Find(NULL,FOFS(dmgteam),"player");
+		goodguy = G_Find(NULL,FOFS(dmgteam), "player");
 		while(goodguy)
 		{
-			if(goodguy->health > 0)
+			if (goodguy->health > 0)
 			{
-				if(!goodguy->enemy)
+				if (!goodguy->enemy)
 				{
-					if(goodguy->monsterinfo.aiflags & AI_ACTOR)
+					if (goodguy->monsterinfo.aiflags & AI_ACTOR)
 					{
 						// Can he see enemy?
-//						tr = gi.trace(goodguy->s.origin,vec3_origin,vec3_origin,self->enemy->s.origin,goodguy,MASK_OPAQUE);
+					//	tr = gi.trace(goodguy->s.origin,vec3_origin,vec3_origin,self->enemy->s.origin,goodguy,MASK_OPAQUE);
-//						if(tr.fraction == 1.0)
+					//	if (tr.fraction == 1.0)
-						if(gi.inPVS(goodguy->s.origin,self->enemy->s.origin))
+						if (gi.inPVS(goodguy->s.origin,self->enemy->s.origin))
 						{
 							goodguy->monsterinfo.aiflags |= AI_FOLLOW_LEADER;
 							goodguy->monsterinfo.old_leader = NULL;
@@ -578,7 +578,7 @@ void FoundTarget (edict_t *self)
 	}
 
 	self->show_hostile = level.time + 1;		// wake up other monsters
-	VectorCopy(self->enemy->s.origin, self->monsterinfo.last_sighting);
+	VectorCopy (self->enemy->s.origin, self->monsterinfo.last_sighting);
 	self->monsterinfo.trail_time = level.time;
 
 	if (!self->combattarget)
@@ -651,7 +651,7 @@ qboolean FindTarget (edict_t *self)
 		}
 
 		// Lazarus: Look for monsters
-		if( !self->enemy )
+		if ( !self->enemy )
 		{
 			if (self->monsterinfo.aiflags & AI_FOLLOW_LEADER)
 			{
@@ -664,17 +664,17 @@ qboolean FindTarget (edict_t *self)
 				for(i=game.maxclients+1; i<globals.num_edicts; i++)
 				{
 					e = &g_edicts[i];
-					if(!e->inuse)
+					if (!e->inuse)
 						continue;
-					if(!(e->svflags & SVF_MONSTER))
+					if (!(e->svflags & SVF_MONSTER))
 						continue;
-					if(e->svflags & SVF_NOCLIENT)
+					if (e->svflags & SVF_NOCLIENT)
 						continue;
-					if(e->solid == SOLID_NOT)
+					if (e->solid == SOLID_NOT)
 						continue;
-					if(e->monsterinfo.aiflags & AI_GOOD_GUY)
+					if (e->monsterinfo.aiflags & AI_GOOD_GUY)
 						continue;
-					if(!visible(self,e))
+					if (!visible(self,e))
 						continue;
 					if (self->monsterinfo.aiflags & AI_BRUTAL)
 					{
@@ -684,13 +684,13 @@ qboolean FindTarget (edict_t *self)
 					else if (e->health <= 0)
 						continue;
 					dist = realrange(self,e);
-					if(dist < best_dist)
+					if (dist < best_dist)
 					{
 						best_dist = dist;
 						best = e;
 					}
 				}
-				if(best)
+				if (best)
 				{
 					self->enemy = best;
 					FoundTarget(self);
@@ -759,14 +759,14 @@ qboolean FindTarget (edict_t *self)
 		return false;
 
 	// Lazarus
-	if(client->client && client->client->camplayer)
+	if (client->client && client->client->camplayer)
 		client = client->client->camplayer;
 
 	if (client == self->enemy)
 		return true;	// JDC false;
 
 	// Lazarus: Force idle medics to look for dead monsters
-	if (!self->enemy && !Q_stricmp(self->classname,"monster_medic"))
+	if (!self->enemy && !Q_stricmp(self->classname, "monster_medic"))
 	{
 		if (medic_FindDeadMonster(self))
 			return true;
@@ -806,7 +806,7 @@ qboolean FindTarget (edict_t *self)
 		for(i=0; i<6 && !reflection; i++)
 		{
 			ref = client->reflection[i];
-			if(ref && visible(self,ref) && infront(self,ref))
+			if (ref && visible(self,ref) && infront(self,ref))
 			{
 				reflection = ref;
 				self_reflection = self->reflection[i];
@@ -879,7 +879,7 @@ qboolean FindTarget (edict_t *self)
 			// If MORON or DUMMY for the parent func_reflect is set,
 			// attack the reflection (in the case of DUMMY, only
 			// if monster doesn't see himself in the same mirror)
-			if( (reflection->activator->spawnflags & 4) ||
+			if ( (reflection->activator->spawnflags & 4) ||
 				( (reflection->activator->spawnflags & 8) &&
 				(!self_reflection || !visible(self,self_reflection)) ) ) // crashes here
 			{
@@ -1277,16 +1277,16 @@ qboolean ai_checkattack (edict_t *self, float dist)
 				self->goalentity = self->movetarget;
 
 				// Lazarus: Let misc_actors who are following their leader RUN even when not mad
-				if( (self->monsterinfo.aiflags & AI_FOLLOW_LEADER) &&
+				if ( (self->monsterinfo.aiflags & AI_FOLLOW_LEADER) &&
 					(self->movetarget) &&
 					(self->movetarget->inuse) )
 				{
 					float	R;
 
 					R = realrange(self,self->movetarget); 
-					if(R > ACTOR_FOLLOW_RUN_RANGE)
+					if (R > ACTOR_FOLLOW_RUN_RANGE)
 						self->monsterinfo.run (self);
-					else if(R > ACTOR_FOLLOW_STAND_RANGE || !self->movetarget->client)
+					else if (R > ACTOR_FOLLOW_STAND_RANGE || !self->movetarget->client)
 						self->monsterinfo.walk (self);
 					else {
 						self->monsterinfo.pausetime = level.time + 0.5;
@@ -1368,7 +1368,7 @@ qboolean ai_checkattack (edict_t *self, float dist)
 	if (!enemy_vis)
 		return false;
 
-	if( self->monsterinfo.checkattack (self) )
+	if ( self->monsterinfo.checkattack (self) )
 	{
 		self->enemy->last_attacked_framenum = level.framenum;
 		return true;
@@ -1456,7 +1456,7 @@ void ai_run (edict_t *self, float dist)
 	if ((!self->enemy) && (self->monsterinfo.aiflags & AI_FOLLOW_LEADER))
 	{
 		self->movetarget = self->goalentity = self->monsterinfo.leader;
-		if(!self->movetarget)
+		if (!self->movetarget)
 		{
 			self->monsterinfo.pausetime = level.time + 2;
 			self->monsterinfo.stand(self);
@@ -1495,7 +1495,7 @@ void ai_run (edict_t *self, float dist)
 			//          lie... pretend the enemy isn't seen.
 			if ( self->monsterinfo.aiflags & AI_MEDIC )
 			{
-				if(realrange(self,realFeind) > MEDIC_MAX_HEAL_DISTANCE)
+				if (realrange(self,realFeind) > MEDIC_MAX_HEAL_DISTANCE)
 				{
 					// Since we're on a hint_path trying to get in position to 
 					// heal monster, rather than actually healing him,
@@ -1505,7 +1505,7 @@ void ai_run (edict_t *self, float dist)
 				}
 			}
 			// if enemy is visible, ATTACK!
-			if(self->enemy && visible(self, realFeind)) pounce = true;
+			if (self->enemy && visible(self, realFeind)) pounce = true;
 		}
 		// if we attack, stop following trail
 		if (pounce) hintpath_stop (self);
@@ -1526,14 +1526,14 @@ void ai_run (edict_t *self, float dist)
 
 		M_MoveToGoal (self, dist);
 		alreadyMoved = true; // this prevents double moves
-		if(!self->inuse)
+		if (!self->inuse)
 			return;
 
 		if (!FindTarget (self))
 			return;
 	}
 
-	if(ai_checkattack (self, dist))
+	if (ai_checkattack (self, dist))
 		return;
 
 	if (self->monsterinfo.attack_state == AS_SLIDING)
@@ -1546,9 +1546,9 @@ void ai_run (edict_t *self, float dist)
 	{
 	//	if (self.aiflags & AI_LOST_SIGHT)
 	//		dprint("regained sight\n");
-		if(!alreadyMoved)
+		if (!alreadyMoved)
 			M_MoveToGoal (self, dist);
-		if(!self->inuse)
+		if (!self->inuse)
 			return;
 		self->monsterinfo.aiflags &= ~AI_LOST_SIGHT;
 		VectorCopy (self->enemy->s.origin, self->monsterinfo.last_sighting);
@@ -1578,20 +1578,20 @@ void ai_run (edict_t *self, float dist)
 	{
 		if (!Q_stricmp(self->classname,"monster_medic") && hint_chains_exist)
 		{
-			if(developer->value)
+			if (developer->value)
 				gi.dprintf("medic search_time=%g\n",level.time - self->monsterinfo.search_time);
 
 			if (level.time > (self->monsterinfo.search_time + 15))
 			{
-				if(developer->value)
+				if (developer->value)
 					gi.dprintf("medic search timeout, going idle\n");
 
-				if(!alreadyMoved)
+				if (!alreadyMoved)
 					M_MoveToGoal (self, dist);
 				self->monsterinfo.search_time = 0;
-				if(self->goalentity == self->enemy)
+				if (self->goalentity == self->enemy)
 					self->goalentity = NULL;
-				if(self->movetarget == self->enemy)
+				if (self->movetarget == self->enemy)
 					self->movetarget = NULL;
 				self->enemy = self->oldenemy = NULL;
 				self->monsterinfo.pausetime = level.time + 2;
@@ -1601,7 +1601,7 @@ void ai_run (edict_t *self, float dist)
 		}
 		else if (level.time > (self->monsterinfo.search_time + 20))
 		{
-			if(!alreadyMoved)
+			if (!alreadyMoved)
 				M_MoveToGoal (self, dist);
 			self->monsterinfo.search_time = 0;
 			return;
@@ -1726,7 +1726,7 @@ void ai_run (edict_t *self, float dist)
 	}
 
 	M_MoveToGoal (self, dist);
-	if(!self->inuse)
+	if (!self->inuse)
 		return;
 
 	G_FreeEdict(tempgoal);
@@ -1803,7 +1803,7 @@ qboolean ai_chicken (edict_t *self, edict_t *badguy)
 
 			testpos[2] = trace1.endpos[2] + self->maxs[2];
 			trace2 = gi.trace(testpos,NULL,NULL,atk,self,MASK_SOLID);
-			if(trace2.fraction == 1.0) continue;
+			if (trace2.fraction == 1.0) continue;
 
 			best_dist = trace1.fraction * travel;
 			if (best_dist < 32) // not much point to this move

game/g_cmds.c

@@ -930,7 +930,7 @@ void Cmd_Use_f (edict_t *ent)
 	}
 	index = ITEM_INDEX(it);
 #ifdef JETPACK_MOD
-	if (!Q_stricmp(s,"jetpack"))
+	if (!Q_stricmp(s, "jetpack"))
 	{
 		// Special case - turns on/off
 		if (!ent->client->jetpack)
@@ -952,7 +952,7 @@ void Cmd_Use_f (edict_t *ent)
 		return;
 	}
 #endif
-	if (!Q_stricmp(s,"stasis generator"))
+	if (!Q_stricmp(s, "stasis generator"))
 	{
 		// Special case - turn freeze off if already on
 		if (level.freeze)
@@ -2456,42 +2456,54 @@ void ClientCommand (edict_t *ent)
 	// debugging/developer stuff
 	else if (developer->value)
 	{
-		if (!Q_stricmp(cmd,"lightswitch"))
+		if (!Q_stricmp(cmd, "lightswitch"))
-			ToggleLights();
+		{
-		else if (!Q_stricmp(cmd,"bbox"))
+			ToggleLights ();
+		}
+		else if (!Q_stricmp(cmd, "bbox"))
+		{
 			Cmd_Bbox_f (ent);
-		else if (!Q_stricmp(cmd,"forcewall"))
+		}
+		else if (!Q_stricmp(cmd, "forcewall"))
 		{
 			SpawnForcewall(ent);
 		}
-		else if (!Q_stricmp(cmd,"forcewall_off"))
+		else if (!Q_stricmp(cmd, "forcewall_off"))
 		{
 			ForcewallOff(ent);
 		}
-		else if (!Q_stricmp(cmd,"freeze"))
+		else if (!Q_stricmp(cmd, "freeze"))
 		{
-			if (level.freeze)
+			if (level.freeze) {
+				gi.dprintf ("Unfreezing time.\n", (int)sk_stasis_time->value);
 				level.freeze = false;
+			}
 			else
 			{
 				if (ent->client->jetpack)
 					gi.dprintf("Cannot use freeze while using jetpack\n");
-				else
+				else {
+					gi.dprintf ("Freezing time for %d seconds.\n", (int)sk_stasis_time->value);
 					level.freeze = true;
+					level.freezeframes = 0;
+				}
 			}
 		}
-		else if (!Q_stricmp(cmd,"hint_test"))
+		else if (!Q_stricmp(cmd, "hint_test"))
 		{
 			edict_t *viewing;
 			int		result;
-			viewing = LookingAt(ent,LOOKAT_MD2,NULL,NULL);
+			viewing = LookingAt(ent, LOOKAT_MD2, NULL, NULL);
 			if (!viewing)
+			{
+				gi.dprintf("Not looking at an entity.\n");
 				return;
+			}
 			if (viewing->monsterinfo.aiflags & AI_HINT_TEST)
 			{
 				viewing->monsterinfo.aiflags &= ~AI_HINT_TEST;
 				gi.dprintf("%s (%s): Back to my normal self now.\n",
-					viewing->classname,viewing->targetname);
+					viewing->classname, viewing->targetname);
 				return;
 			}
 			if (!(viewing->svflags & SVF_MONSTER))
@@ -2510,12 +2522,14 @@ void ClientCommand (edict_t *ent)
 			 			viewing->classname, (viewing->targetname ? viewing->targetname : "<noname>"),
 						(viewing->movetarget->targetname ? viewing->movetarget->targetname : "<noname>"),
 						vtos(viewing->movetarget->s.origin),
-						visible(viewing,viewing->movetarget) ? "I see it." : "I don't see it.");
+						visible(viewing, viewing->movetarget) ? "I see it." : "I don't see it.");
+				break;
+			default:
+				gi.dprintf("Unknown error\n");
 				break;
-			default: gi.dprintf("Unknown error\n");
 			}
 		}
-		else if (!Q_stricmp(cmd,"entid"))
+		else if (!Q_stricmp(cmd, "entid"))
 		{
 			edict_t *viewing;
 			vec3_t	origin;
@@ -2566,7 +2580,7 @@ void ClientCommand (edict_t *ent)
 		else if (strstr(cmd, "muzzle"))
 		{
 			edict_t	*viewing;
-			viewing = LookingAt(ent,0,NULL,NULL);
+			viewing = LookingAt(ent, 0, NULL, NULL);
 			if (!viewing)
 				return;
 			if (!viewing->classname)
@@ -2597,11 +2611,11 @@ void ClientCommand (edict_t *ent)
 			VectorCopy(ent->s.origin,start);
 
 			start[2] += ent->viewheight;
-			AngleVectors(ent->client->v_angle,forward,NULL,NULL);
+			AngleVectors (ent->client->v_angle, forward, NULL, NULL);
-			VectorMA(start, WORLD_SIZE, forward, point);	// was 8192
+			VectorMA (start, WORLD_SIZE, forward, point);	// was 8192
-			tr = gi.trace(start,NULL,NULL,point,ent,MASK_SOLID);
+			tr = gi.trace(start, NULL, NULL, point, ent, MASK_SOLID);
-			VectorSubtract(tr.endpos,start,point);
+			VectorSubtract (tr.endpos, start, point);
-			gi.dprintf("range=%g\n",VectorLength(point));
+			gi.dprintf ("range=%g\n", VectorLength(point));
 		}
 		else if (!Q_stricmp(cmd, "setskill"))
 		{
@@ -2618,17 +2632,17 @@ void ClientCommand (edict_t *ent)
 			edict_t *viewing;
 			int		skinnum;
 
-			viewing = LookingAt(ent,0,NULL,NULL);
+			viewing = LookingAt(ent ,0, NULL, NULL);
 			if (!viewing) 
 				return;
 
 			if (parm) {
 				skinnum = atoi(parm);
 				viewing->s.skinnum = skinnum;
-				gi.linkentity(viewing);
+				gi.linkentity (viewing);
 			}
 			else
-				gi.dprintf("Currently using skin #%i\n",viewing->s.skinnum);
+				gi.dprintf("Currently using skin #%i\n", viewing->s.skinnum);
 
 		}
 		else if (!Q_stricmp(cmd, "spawn"))
@@ -2647,8 +2661,8 @@ void ClientCommand (edict_t *ent)
 			e->classname = gi.TagMalloc(classSize, TAG_LEVEL);
 		//	strncpy(e->classname, parm);
 			Q_strncpyz (e->classname, classSize, parm);
-			AngleVectors(ent->client->v_angle,forward,NULL,NULL);
+			AngleVectors (ent->client->v_angle, forward, NULL, NULL);
-			VectorMA(ent->s.origin,128,forward,e->s.origin);
+			VectorMA (ent->s.origin, 128, forward, e->s.origin);
 			e->s.angles[YAW] = ent->s.angles[YAW];
 			ED_CallSpawn(e);
 		}
@@ -2671,12 +2685,12 @@ void ClientCommand (edict_t *ent)
 			e->usermodel = gi.argv(1);
 			e->sounds = atoi(gi.argv(2));
 			e->spawnflags = SF_MONSTER_GOODGUY;
-			AngleVectors(ent->client->v_angle,forward,NULL,NULL);
+			AngleVectors (ent->client->v_angle, forward, NULL, NULL);
-			VectorMA(ent->s.origin,128,forward,e->s.origin);
+			VectorMA (ent->s.origin, 128, forward, e->s.origin);
 			e->s.origin[2] = max(e->s.origin[2],ent->s.origin[2] + 8);
 			e->s.angles[YAW] = ent->s.angles[YAW];
-			ED_CallSpawn(e);
+			ED_CallSpawn (e);
-			actor_files();
+			actor_files ();
 		}
 		else if (!Q_stricmp(cmd, "spawnself"))
 		{
@@ -2688,8 +2702,8 @@ void ClientCommand (edict_t *ent)
 			memcpy(&decoy->s,&ent->s,sizeof(entity_state_t));
 			decoy->s.number     = decoy-g_edicts;
 			decoy->s.frame      = ent->s.frame; 
-			AngleVectors(ent->client->v_angle,forward,NULL,NULL);
+			AngleVectors (ent->client->v_angle, forward, NULL, NULL);
-			VectorMA(ent->s.origin,64,forward,decoy->s.origin);
+			VectorMA (ent->s.origin, 64, forward, decoy->s.origin);
 			decoy->s.angles[YAW] = ent->s.angles[YAW]; 
 			decoy->takedamage   = DAMAGE_AIM;
 			decoy->flags        = (ent->flags & FL_NOTARGET);
@@ -2705,8 +2719,8 @@ void ClientCommand (edict_t *ent)
 			decoy->monsterinfo.aiflags = AI_GOOD_GUY;
 			decoy->die          = decoy_die;
 			decoy->nextthink    = level.time + FRAMETIME;
-			VectorCopy(ent->mins,decoy->mins);
+			VectorCopy (ent->mins, decoy->mins);
-			VectorCopy(ent->maxs,decoy->maxs);
+			VectorCopy (ent->maxs, decoy->maxs);
 			gi.linkentity (decoy); 
 		}
 		else if (!Q_stricmp(cmd, "switch"))
@@ -2714,7 +2728,7 @@ void ClientCommand (edict_t *ent)
 			extern mmove_t	actor_move_switch;
 			edict_t *viewing;
 
-			viewing = LookingAt(ent,0,NULL,NULL);
+			viewing = LookingAt(ent, 0, NULL, NULL);
 			if (!viewing)
 				return;
 			if (!(viewing->monsterinfo.aiflags & AI_ACTOR))
@@ -2724,6 +2738,29 @@ void ClientCommand (edict_t *ent)
 			}
 			viewing->monsterinfo.currentmove = &actor_move_switch;
 		}
+		else if (!Q_stricmp(cmd, "resettargets"))
+		{
+			edict_t	*e;
+			int		i;
+			int		count;
+
+			gi.dprintf("Resetting all monsters' enemies...\n");
+			count = 0;
+			for (i=0, e=&g_edicts[0]; i<globals.num_edicts; i++, e++)
+			{
+				if (!e->inuse)
+					continue;
+				if ( !(e->svflags & SVF_MONSTER) )
+					continue;
+				if (e->health <= 0)
+					continue;
+				e->enemy = e->oldenemy = NULL;
+				e->monsterinfo.pausetime = 0;
+				e->monsterinfo.stand (e);
+				count++;
+			}
+			gi.dprintf("reset %d monsters' enemies, done.\n", count);
+		}
 #ifndef KMQUAKE2_ENGINE_MOD // these functions moved clientside in engine
 		else if (!Q_stricmp(cmd, "texture"))
 		{
@@ -2736,8 +2773,8 @@ void ClientCommand (edict_t *ent)
 				VectorCopy(ent->s.origin, start);
 				start[2] += ent->viewheight;
 			}
-			AngleVectors(ent->client->v_angle, forward, NULL, NULL);
+			AngleVectors (ent->client->v_angle, forward, NULL, NULL);
-			VectorMA(start, WORLD_SIZE, forward, end);	// was 8192
+			VectorMA (start, WORLD_SIZE, forward, end);	// was 8192
 			tr = gi.trace(start, NULL, NULL, end, ent, MASK_ALL);
 			if (!tr.ent)
 				gi.dprintf("Nothing hit?\n");
@@ -2768,8 +2805,8 @@ void ClientCommand (edict_t *ent)
 				VectorCopy(ent->s.origin, start);
 				start[2] += ent->viewheight;
 			}
-			AngleVectors(ent->client->v_angle, forward, NULL, NULL);
+			AngleVectors (ent->client->v_angle, forward, NULL, NULL);
-			VectorMA(start, WORLD_SIZE, forward, end);	// was 8192
+			VectorMA (start, WORLD_SIZE, forward, end);	// was 8192
 			tr = gi.trace(start, NULL, NULL, end, ent, MASK_ALL);
 			if (!tr.ent)
 				gi.dprintf("Nothing hit?\n");

game/g_combat.c

@@ -406,10 +406,10 @@ void CallMyFriends (edict_t *targ, edict_t *attacker)
 					{
 						targ->enemy = targ->movetarget = targ->goalentity = attacker;
 						targ->monsterinfo.aiflags &= ~AI_FOLLOW_LEADER;
-						if (visible(targ,targ->enemy))
+						if (visible(targ, targ->enemy))
-							FoundTarget(targ);
+							FoundTarget (targ);
 						else
-							HuntTarget(targ);
+							HuntTarget (targ);
 					}
 				}
 				else if ( !(targ->svflags & SVF_MONSTER) || !(attacker->svflags & SVF_MONSTER) ||
@@ -419,7 +419,7 @@ void CallMyFriends (edict_t *targ, edict_t *attacker)
 					// Either target is not a monster, or attacker is not a monster, or
 					// they're both monsters but one is AI_GOOD_GUY and the other is not,
 					// or we've turned the game into a free-for-all with a target_monsterbattle
-					teammate = G_Find(NULL,FOFS(dmgteam),targ->dmgteam);
+					teammate = G_Find(NULL, FOFS(dmgteam), targ->dmgteam);
 					while (teammate)
 					{
 						if (teammate != targ)
@@ -436,18 +436,18 @@ void CallMyFriends (edict_t *targ, edict_t *attacker)
 										// then set the attacker as the enemy of this teammate
 										DefendMyFriend(teammate,attacker);
 									}
-									else if (strcmp(teammate->enemy->dmgteam,attacker->dmgteam))
+									else if (strcmp(teammate->enemy->dmgteam, attacker->dmgteam))
 									{
 										// attacker is a member of a team different than the
 										// current enemy
-										DefendMyFriend(teammate,attacker);
+										DefendMyFriend (teammate, attacker);
 									}
 								}
 							}
 							else if (!(teammate->svflags & SVF_DEADMONSTER))
-								G_UseTargets(teammate,attacker);
+								G_UseTargets (teammate, attacker);
 						}
-						teammate = G_Find(teammate,FOFS(dmgteam),targ->dmgteam);
+						teammate = G_Find(teammate, FOFS(dmgteam), targ->dmgteam);
 					}
 				}
 			}
@@ -458,14 +458,14 @@ void CallMyFriends (edict_t *targ, edict_t *attacker)
 		// target is player; attacker is monster... alert "good guys", if any
 //		trace_t	tr;
 		edict_t	*teammate = NULL;
-		teammate = G_Find(NULL,FOFS(dmgteam),"player");
+		teammate = G_Find(NULL, FOFS(dmgteam), "player");
 		while (teammate)
 		{
 			if ((teammate->health > 0) && !(teammate->monsterinfo.aiflags & AI_CHASE_THING) && (teammate != attacker))
 			{
 				// Can teammate see player?
-//				tr = gi.trace(teammate->s.origin,vec3_origin,vec3_origin,targ->s.origin,teammate,MASK_OPAQUE);
+			//	tr = gi.trace(teammate->s.origin,vec3_origin,vec3_origin,targ->s.origin,teammate,MASK_OPAQUE);
-//				if (tr.fraction == 1.0)
+			//	if (tr.fraction == 1.0)
 				if (gi.inPVS(teammate->s.origin,targ->s.origin))
 				{
 					teammate->enemy = attacker;
@@ -478,7 +478,7 @@ void CallMyFriends (edict_t *targ, edict_t *attacker)
 					}
 				}
 			}
-			teammate = G_Find(teammate,FOFS(dmgteam),"player");
+			teammate = G_Find(teammate, FOFS(dmgteam), "player");
 		}
 	}
 	// If player attacks a GOODGUY, turn GOODGUY stuff off

game/g_lights.c

@@ -24,7 +24,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #include "g_local.h"
 //==========================================================
 
-void Lights()
+void Lights (void)
 {
 	if (lights->value)
 	{
@@ -82,16 +82,16 @@ void Lights()
 	}
 }
 
-void ToggleLights()
+void ToggleLights (void)
 {
 	gi.cvar_set ("lights", va("%i", !lights->value));
 //	lights->value = !lights->value;
-	Lights();
+	Lights ();
 }
 
 void target_lightswitch_toggle (edict_t *self)
 {
-	ToggleLights();
+	ToggleLights ();
 
 	self->count--;
 	if(!self->count) {

game/g_local.h

@@ -104,6 +104,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #define	FL2_TURRET_DOUBLE		0x00000001	// this is a double-barreled turret
 #define	FL2_TURRET_DOUBLE_ALT	0x00000002	// this turret alternates firing its barrels (style is set)
 #define	FL2_TURRET_DOUBLE_ALT_FIRING	0x00000004		// secondary barrel in use for alternate firing
+#define FL2_CRUCIFIED			0x00000008	// insane is crucified 
 
 
 #define	FRAMETIME		0.1

game/g_main.c

@@ -158,7 +158,7 @@ void G_RunFrame (void);
 void ShutdownGame (void)
 {
 	gi.dprintf ("==== ShutdownGame ====\n");
-	if(!deathmatch->value && !coop->value) {
+	if (!deathmatch->value && !coop->value) {
 #ifndef KMQUAKE2_ENGINE_MOD // engine has zoom autosensitivity
 		gi.cvar_forceset("m_pitch", va("%f",lazarus_pitch->value));
 #endif
@@ -185,7 +185,7 @@ int Debug_Modelindex (char *name)
 {
 	int	modelnum;
 	modelnum = RealFunc.modelindex(name);
-	if(modelnum > max_modelindex)
+	if (modelnum > max_modelindex)
 	{
 		gi.dprintf("Model %03d %s\n",modelnum,name);
 		max_modelindex = modelnum;
@@ -197,7 +197,7 @@ int Debug_Soundindex (char *name)
 {
 	int soundnum;
 	soundnum = RealFunc.soundindex(name);
-	if(soundnum > max_soundindex)
+	if (soundnum > max_soundindex)
 	{
 		gi.dprintf("Sound %03d %s\n",soundnum,name);
 		max_soundindex = soundnum;
@@ -540,12 +540,13 @@ void G_RunFrame (void)
 	if (paused && deathmatch->value)
 		return;
 
-	if(level.freeze)
+	if (level.freeze)
 	{
 		level.freezeframes++;
-		if(level.freezeframes >= sk_stasis_time->value*10)
+		if (level.freezeframes >= sk_stasis_time->value*10)
 			level.freeze = false;
-	} else
+	}
+	else
 		level.framenum++;
 
 	level.time = level.framenum*FRAMETIME;

game/g_monster.c

@@ -528,7 +528,8 @@ void M_MoveFrame (edict_t *self)
 
 	// Lazarus: For live monsters weaker than gladiator who aren't already running from
 	//          something, evade live grenades on the ground.
-	if ((self->health > 0) && (self->max_health < 400) && !(self->monsterinfo.aiflags & AI_CHASE_THING) && self->monsterinfo.run)
+	if ( (self->health > 0) && (self->max_health < 400) && !(self->monsterinfo.aiflags & AI_CHASE_THING) && self->monsterinfo.run
+		&& !((Q_stricmp(self->classname, "misc_insane") == 0) && (self->moreflags & FL2_CRUCIFIED)) )	// Knightmare- crucified insanes don't evade
 		Grenade_Evade (self);
 
 	move = self->monsterinfo.currentmove;
@@ -1416,6 +1417,7 @@ int PatchMonsterModel (char *modelname)
 	return 1;
 }
 
+
 void HintTestNext (edict_t *self, edict_t *hint)
 {
 	edict_t		*next=NULL;
@@ -1455,7 +1457,7 @@ void HintTestNext (edict_t *self, edict_t *hint)
 	if (next)
 	{
 		self->hint_chain_id = next->hint_chain_id;
-		VectorSubtract(next->s.origin, self->s.origin, dir);
+		VectorSubtract (next->s.origin, self->s.origin, dir);
 		self->ideal_yaw = vectoyaw(dir);
 		self->goalentity = self->movetarget = next;
 		self->monsterinfo.pausetime = 0;
@@ -1497,11 +1499,11 @@ int HintTestStart (edict_t *self)
 			e = &g_edicts[i];
 			if (!e->inuse)
 				continue;
-			if (Q_stricmp(e->classname,"hint_path"))
+			if (Q_stricmp(e->classname, "hint_path"))
 				continue;
-			if (!visible(self,e))
+			if (!visible(self, e))
 				continue;
-			if (!canReach(self,e))
+			if (!canReach(self, e))
 				continue;
 			VectorSubtract(e->s.origin,self->s.origin,dir);
 			dist = VectorLength(dir);

game/g_moreai.c

@@ -47,7 +47,8 @@ Initializes all hint_path chains in a map.
 */
 void SetupHintPaths (void)
 {
-	int		i, keyofs;
+	int		i;
+	size_t	keyofs;
 	edict_t	*thisPath, *ent;
 
 	// check if there are any hint_paths in this map first
@@ -418,14 +419,14 @@ void touch_hint_path (edict_t *hintpath, edict_t *monster, cplane_t *plane, csur
 	if (monster->monsterinfo.aiflags & AI_MEDIC_PATROL) 
 	{
 		if (monster->movetarget == hintpath)
-			medic_NextPatrolPoint(monster, hintpath);
+			medic_NextPatrolPoint (monster, hintpath);
 		return;
 	}
 
 	if (monster->monsterinfo.aiflags & AI_HINT_TEST)
 	{
 		if (monster->movetarget == hintpath)
-			HintTestNext(monster, hintpath);
+			HintTestNext (monster, hintpath);
 		return;
 	}
 

game/g_phys.c

@@ -182,8 +182,8 @@ void SV_CheckVelocity (edict_t *ent)
 	} */
 	if (VectorLength(ent->velocity) > sv_maxvelocity->value)
 	{
-		VectorNormalize(ent->velocity);
+		VectorNormalize (ent->velocity);
-		VectorScale(ent->velocity, sv_maxvelocity->value, ent->velocity);
+		VectorScale (ent->velocity, sv_maxvelocity->value, ent->velocity);
 	}
 }
 

game/m_gunner.c

@@ -384,7 +384,7 @@ void gunner_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damag
 	self->monsterinfo.currentmove = &gunner_move_death;
 }
 
-qboolean gunner_grenade_check(edict_t *self)
+qboolean gunner_grenade_check (edict_t *self)
 {
 	vec3_t		start;
 	vec3_t		forward, right;
@@ -416,18 +416,18 @@ qboolean gunner_grenade_check(edict_t *self)
 		return false;
 
 	// Lazarus: Max vertical distance - this is approximate and conservative
-	VectorCopy(dir,vhorz);
+	VectorCopy (dir, vhorz);
 	vhorz[2] = 0;
-	horz = VectorLength(vhorz);
+	horz = VectorLength (vhorz);
-	vertmax = (GRENADE_VELOCITY_SQUARED)/(2*sv_gravity->value) -
+	vertmax = (GRENADE_VELOCITY_SQUARED) / (2 * sv_gravity->value) -
-		0.5*sv_gravity->value*horz*horz/GRENADE_VELOCITY_SQUARED;
+		0.5 * sv_gravity->value * horz * horz / GRENADE_VELOCITY_SQUARED;
 	if (dir[2] > vertmax) 
 		return false;
 
 	// Lazarus: Make sure there's a more-or-less clear flight path to target
 	// Rogue checked target origin, but if target is above gunner then the trace
 	// would almost always hit the platform the target was standing on
-	VectorCopy(self->enemy->s.origin,target);
+	VectorCopy (self->enemy->s.origin, target);
 	target[2] = self->enemy->absmax[2];
 	tr = gi.trace(start, vec3_origin, vec3_origin, target, self, MASK_SHOT);
 	if (tr.ent == self->enemy || tr.fraction == 1)

game/m_insane.c

@@ -506,7 +506,7 @@ void insane_pain (edict_t *self, edict_t *other, float kick, int damage)
 
 	// Don't go into pain frames if crucified.
 //	if (self->spawnflags & 8)
-	if ( (self->spawnflags & 8) || (self->moreflags & 8) )	// Knightmare- use moreflags field instead
+	if ( (self->spawnflags & 8) || (self->moreflags & FL2_CRUCIFIED) )	// Knightmare- use moreflags field instead
 	{
 		self->monsterinfo.currentmove = &insane_move_struggle_cross;			
 		return;
@@ -551,7 +551,7 @@ void insane_checkup (edict_t *self)
 void insane_stand (edict_t *self)
 {
 //	if (self->spawnflags & 8)			// If crucified
-	if ( (self->spawnflags & 8) || (self->moreflags & 8) )	// If crucified		// Knightmare- use moreflags field instead
+	if ( (self->spawnflags & 8) || (self->moreflags & FL2_CRUCIFIED) )	// If crucified		// Knightmare- use moreflags field instead
 	{
 		self->monsterinfo.currentmove = &insane_move_cross;
 		self->monsterinfo.aiflags |= AI_STAND_GROUND;
@@ -570,7 +570,7 @@ void insane_stand (edict_t *self)
 void insane_dead (edict_t *self)
 {
 //	if (self->spawnflags & 8)
-	if ( (self->spawnflags & 8) || (self->moreflags & 8) )	// Knightmare- use moreflags field instead
+	if ( (self->spawnflags & 8) || (self->moreflags & FL2_CRUCIFIED) )	// Knightmare- use moreflags field instead
 	{
 		self->flags |= FL_FLY;
 	}
@@ -619,7 +619,7 @@ void insane_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damag
 	self->takedamage = DAMAGE_YES;
 
 //	if (self->spawnflags & 8)
-	if ( (self->spawnflags & 8) || (self->moreflags & 8) )	// Knightmare- use moreflags field instead
+	if ( (self->spawnflags & 8) || (self->moreflags & FL2_CRUCIFIED) )	// Knightmare- use moreflags field instead
 	{
 		insane_dead (self);
 	}
@@ -708,7 +708,7 @@ void SP_misc_insane (edict_t *self)
 	{
 		// Knightmare- Spawnflag 8 collides with SF_MONSTER_GOODGUY, and can be cleared in some instances.
 		// This prevents it from screwing up crucified insanes.
-		self->moreflags |= 8;
+		self->moreflags |= FL2_CRUCIFIED;
 		VectorSet (self->mins, -16, 0, 0);
 		VectorSet (self->maxs, 16, 8, 32);
 		self->flags |= FL_NO_KNOCKBACK;

game/p_hud.c

@@ -361,7 +361,7 @@ void HelpComputer (edict_t *ent)
 		sk = "hard+";
 
 	// send the layout
-	if(world->effects & FX_WORLDSPAWN_NOHELP)
+	if (world->effects & FX_WORLDSPAWN_NOHELP)
 	{
 		Com_sprintf (string, sizeof(string),
 			"xv %d yv %d picn help ",(int)(world->bleft[0]),(int)(world->bleft[1]));
@@ -708,13 +708,13 @@ void G_SetStats (edict_t *ent)
 	{
 		if (ent->client->showscores || ent->client->showhelp || ent->client->showinventory)
 			ent->client->whatsit = NULL;
-		else if(!(level.framenum % 5))    // only update every 1/2 second
+		else if (!(level.framenum % 5))    // only update every 1/2 second
 		{
 			char *temp = ent->client->whatsit;
 
 			ent->client->whatsit = NULL;
 			WhatIsIt(ent);
-			if(ent->client->whatsit && !temp)
+			if (ent->client->whatsit && !temp)
 				WhatsIt(ent);
 		}
 	}
@@ -741,7 +741,7 @@ void G_SetStats (edict_t *ent)
 		if (ent->client->showinventory && ent->client->pers.health > 0)
 			ent->client->ps.stats[STAT_LAYOUTS] |= 2;
 	}
-	if(!ent->client->ps.stats[STAT_LAYOUTS] && ent->client->whatsit)
+	if (!ent->client->ps.stats[STAT_LAYOUTS] && ent->client->whatsit)
 		ent->client->ps.stats[STAT_LAYOUTS] |= 1;
 
 	//

game/p_view.c

@@ -527,15 +527,15 @@ void SV_CalcBlend (edict_t *ent)
 	if (level.freeze && (level.freezeframes % 30 == 0))
 	{
 		if (level.freezeframes == (sk_stasis_time->value*10 - 30)) // was 270
-			gi.sound(ent,CHAN_ITEM,gi.soundindex("items/stasis_stop.wav"), 1, ATTN_NORM, 0);
+			gi.sound(ent, CHAN_ITEM, gi.soundindex("items/stasis_stop.wav"), 1, ATTN_NORM, 0);
 		else
-			gi.sound(ent,CHAN_ITEM,gi.soundindex("items/stasis.wav"), 1, ATTN_NORM, 0);
+			gi.sound(ent, CHAN_ITEM, gi.soundindex("items/stasis.wav"), 1, ATTN_NORM, 0);
 	}
 
 	// add for damage
 	if (ent->client->damage_alpha > 0)
-		SV_AddBlend (ent->client->damage_blend[0],ent->client->damage_blend[1]
+		SV_AddBlend (ent->client->damage_blend[0], ent->client->damage_blend[1],
-		,ent->client->damage_blend[2], ent->client->damage_alpha, ent->client->ps.blend);
+		ent->client->damage_blend[2], ent->client->damage_alpha, ent->client->ps.blend);
 
 	if (ent->client->bonus_alpha > 0)
 		SV_AddBlend (0.85, 0.7, 0.3, ent->client->bonus_alpha, ent->client->ps.blend);

missionpack/g_ai.c

@@ -593,7 +593,7 @@ void FoundTarget (edict_t *self)
 		level.sight_entity->light_level = 128;
 
 		goodguy = NULL;
-		goodguy = G_Find(NULL,FOFS(dmgteam), "player");
+		goodguy = G_Find(NULL, FOFS(dmgteam), "player");
 		while (goodguy)
 		{
 			if (goodguy->health > 0)
@@ -614,7 +614,7 @@ void FoundTarget (edict_t *self)
 					}
 				}
 			}
-			goodguy = G_Find(goodguy,FOFS(dmgteam),"player");
+			goodguy = G_Find(goodguy, FOFS(dmgteam), "player");
 		}
 	}
 
@@ -689,8 +689,8 @@ qboolean FindTarget (edict_t *self)
 	edict_t		*reflection = NULL;		
 	edict_t		*self_reflection = NULL;
 
-//	if  ((self->monsterinfo.aiflags & AI_CHASE_THING) || (self->monsterinfo.aiflags2 & AI2_HINT_TEST) )
+	if  ((self->monsterinfo.aiflags & AI_CHASE_THING) || (self->monsterinfo.aiflags2 & AI2_HINT_TEST) )
-//		return false;
+		return false;
 
 	if (self->monsterinfo.aiflags & AI_GOOD_GUY) 
 	{
@@ -1328,13 +1328,14 @@ void ai_run_slide(edict_t *self, float distance)
 		ofs = angle;
 	else
 		ofs = -angle;
-//
+
-//	if (!(self->flags & FL_FLY))
+/*	if (!(self->flags & FL_FLY))
-//	{
+	{
-//		// non fliers should actually turn towards the direction their trying to run
+		// non fliers should actually turn towards the direction their trying to run
-//		self->ideal_yaw += ofs;
+		self->ideal_yaw += ofs;
-//	}
+	}
-//
+*/
+
 	if (!(self->monsterinfo.aiflags & AI_MANUAL_STEERING))
 		M_ChangeYaw (self);
 
@@ -1661,11 +1662,13 @@ void ai_run (edict_t *self, float dist)
 	// end Zaero
 
 	// if we're going to a combat point, just proceed
-	if (self->monsterinfo.aiflags & (AI_COMBAT_POINT | AI_CHASE_THING))
+	if ( (self->monsterinfo.aiflags & (AI_COMBAT_POINT | AI_CHASE_THING))
+		|| (self->monsterinfo.aiflags2 & AI2_HINT_TEST) )
 	{
 		M_MoveToGoal (self, dist);
 		return;
 	}
+
 	if ( self->monsterinfo.aiflags & AI_MEDIC_PATROL )
 	{
 		if (!FindTarget(self))
@@ -1816,13 +1819,13 @@ void ai_run (edict_t *self, float dist)
 		// if we see the player, stop following hintpaths.
 		if (gotcha)
 		{
-//			if (g_showlogic && g_showlogic->value)
+		//	if (g_showlogic && g_showlogic->value)
-//				gi.dprintf("stopped following hint paths in ai_run\n");
+		//		gi.dprintf("stopped following hint paths in ai_run\n");
 
 			// disconnect from hintpaths and start looking normally for players.
 			hintpath_stop (self);
 			// pmm - no longer needed, since hintpath_stop does it
-//			HuntTarget(self);
+		//	HuntTarget(self);
 		}
 		return;
 	}
@@ -1913,20 +1916,20 @@ void ai_run (edict_t *self, float dist)
 		return;
 	}
 	//PMM
-//	if (ai_checkattack (self, dist))
+/*	if (ai_checkattack (self, dist))
-//		return;
+		return;
-
-//	if (self->monsterinfo.attack_state == AS_SLIDING)
-//	{
-//		ai_run_slide (self, dist);
-//		return;
-//	}
 
+	if (self->monsterinfo.attack_state == AS_SLIDING)
+	{
+		ai_run_slide (self, dist);
+		return;
+	}
+*/
 	// PGM - added a little paranoia checking here... 9/22/98
 	if ((self->enemy) && (self->enemy->inuse) && (enemy_vis))
 	{
-//		if (self->monsterinfo.aiflags & AI_LOST_SIGHT)
+	//	if (self->monsterinfo.aiflags & AI_LOST_SIGHT)
-//			gi.dprintf("regained sight\n");
+	//		gi.dprintf("regained sight\n");
 		// PMM - check for alreadyMoved
 		if (!alreadyMoved)
 			M_MoveToGoal (self, dist);
@@ -1976,7 +1979,7 @@ void ai_run (edict_t *self, float dist)
 		if (!alreadyMoved)
 			M_MoveToGoal (self, dist);
 		self->monsterinfo.search_time = 0;
-//		gi.dprintf("search timeout\n");
+	//	gi.dprintf("search timeout\n");
 		return;
 	}
 
@@ -1989,7 +1992,7 @@ void ai_run (edict_t *self, float dist)
 	if (!(self->monsterinfo.aiflags & AI_LOST_SIGHT))
 	{
 		// just lost sight of the player, decide where to go first
-//		gi.dprintf("lost sight of player, last seen at %s\n", vtos(self->monsterinfo.last_sighting));
+	//	gi.dprintf("lost sight of player, last seen at %s\n", vtos(self->monsterinfo.last_sighting));
 		self->monsterinfo.aiflags |= (AI_LOST_SIGHT | AI_PURSUIT_LAST_SEEN);
 		self->monsterinfo.aiflags &= ~(AI_PURSUE_NEXT | AI_PURSUE_TEMP);
 		new = true;
@@ -1997,18 +2000,18 @@ void ai_run (edict_t *self, float dist)
 
 	if (self->monsterinfo.aiflags & AI_PURSUE_NEXT)
 	{
-//		vec3_t	debug_vec;
+	//	vec3_t	debug_vec;
 
 		self->monsterinfo.aiflags &= ~AI_PURSUE_NEXT;
-//		VectorSubtract(self->monsterinfo.last_sighting, self->s.origin, debug_vec);
+	//	VectorSubtract(self->monsterinfo.last_sighting, self->s.origin, debug_vec);
-//		gi.dprintf("reached current goal: %s %s %f", vtos(self->s.origin), vtos(self->monsterinfo.last_sighting), VectorLength(debug_vec));
+	//	gi.dprintf("reached current goal: %s %s %f", vtos(self->s.origin), vtos(self->monsterinfo.last_sighting), VectorLength(debug_vec));
 
 		// give ourself more time since we got this far
 		self->monsterinfo.search_time = level.time + 5;
 
 		if (self->monsterinfo.aiflags & AI_PURSUE_TEMP)
 		{
-//			gi.dprintf("was temp goal; retrying original\n");
+		//	gi.dprintf("was temp goal; retrying original\n");
 			self->monsterinfo.aiflags &= ~AI_PURSUE_TEMP;
 			marker = NULL;
 			VectorCopy (self->monsterinfo.saved_goal, self->monsterinfo.last_sighting);

missionpack/g_cmds.c

@@ -2304,24 +2304,79 @@ void ClientCommand (edict_t *ent)
 		else
 			gi.dprintf("syntax: whereis <classname>\n");
 	}
-	else if (!Q_stricmp(cmd, "bbox"))
-		Cmd_Bbox_f (ent);
 	else if (developer->value)
 	{
-		if (!Q_stricmp(cmd, "forcewall"))
+		if (!Q_stricmp(cmd, "lightswitch"))
+		{
+			ToggleLights ();
+		}
+		else if (!Q_stricmp(cmd, "bbox"))
+		{
+			Cmd_Bbox_f (ent);
+		}
+		else if (!Q_stricmp(cmd, "forcewall"))
+		{
 			SpawnForcewall (ent);
+		}
 		else if (!Q_stricmp(cmd, "forcewall_off"))
+		{
 			ForcewallOff (ent);
+		}
 		else if (!Q_stricmp(cmd, "freeze"))
 		{
-			if (level.freeze)
+			if (level.freeze) {
+				gi.dprintf ("Unfreezing time.\n", (int)sk_stasis_time->value);
 				level.freeze = false;
+			}
 			else
 			{
 				if (ent->client->jetpack)
 					gi.dprintf("Cannot use freeze while using jetpack\n");
-				else
+				else {
+					gi.dprintf ("Freezing time for %d seconds.\n", (int)sk_stasis_time->value);
 					level.freeze = true;
+					level.freezeframes = 0;
+				}
+			}
+		}
+		else if (!Q_stricmp(cmd, "hint_test"))
+		{
+			edict_t *viewing;
+			int		result;
+			viewing = LookingAt(ent, LOOKAT_MD2, NULL, NULL);
+			if (!viewing)
+			{
+				gi.dprintf("Not looking at an entity.\n");
+				return;
+			}
+			if (viewing->monsterinfo.aiflags2 & AI2_HINT_TEST)
+			{
+				viewing->monsterinfo.aiflags2 &= ~AI2_HINT_TEST;
+				gi.dprintf("%s (%s): Back to my normal self now.\n",
+					viewing->classname, viewing->targetname);
+				return;
+			}
+			if (!(viewing->svflags & SVF_MONSTER))
+				gi.dprintf("hint_test is only valid for monsters and actors.\n");
+			result = HintTestStart(viewing);
+			switch (result)
+			{
+			case -1:
+				gi.dprintf("%s (%s): I cannot see any hint_paths from here.\n");
+				break;
+			case  0:
+				gi.dprintf("This map does not contain hint_paths.\n");
+				break;
+			case  1:
+				gi.dprintf("%s (%s) searching for hint_path %s at %s. %s\n",
+			 			viewing->classname, (viewing->targetname ? viewing->targetname : "<noname>"),
+						(viewing->movetarget->targetname ? viewing->movetarget->targetname : "<noname>"),
+						vtos(viewing->movetarget->s.origin),
+						visible(viewing, viewing->movetarget) ? "I see it." : "I don't see it.");
+				break;
+			default:
+				gi.dprintf("Unknown error\n");
+				break;
 			}
 		}
 		else if (!Q_stricmp(cmd, "entid"))
@@ -2444,8 +2499,8 @@ void ClientCommand (edict_t *ent)
 			classSize = strlen(parm)+1;
 			e->classname = gi.TagMalloc(classSize, TAG_LEVEL);
 			Com_strcpy (e->classname, classSize, parm);
-			AngleVectors(ent->client->v_angle,forward,NULL,NULL);
+			AngleVectors (ent->client->v_angle, forward, NULL, NULL);
-			VectorMA(ent->s.origin,128,forward,e->s.origin);
+			VectorMA (ent->s.origin, 128, forward, e->s.origin);
 			e->s.angles[YAW] = ent->s.angles[YAW];
 			ED_CallSpawn(e);
 		}
@@ -2467,9 +2522,9 @@ void ClientCommand (edict_t *ent)
 			e->usermodel = gi.argv(1);
 			e->sounds = atoi(gi.argv(2));
 			e->spawnflags = SF_MONSTER_GOODGUY;
-			AngleVectors(ent->client->v_angle,forward,NULL,NULL);
+			AngleVectors (ent->client->v_angle, forward, NULL, NULL);
-			VectorMA(ent->s.origin,128,forward,e->s.origin);
+			VectorMA (ent->s.origin, 128, forward, e->s.origin);
-			e->s.origin[2] = max(e->s.origin[2],ent->s.origin[2] + 8);
+			e->s.origin[2] = max(e->s.origin[2], ent->s.origin[2] + 8);
 			e->s.angles[YAW] = ent->s.angles[YAW];
 			ED_CallSpawn(e);
 			actor_files();
@@ -2484,8 +2539,8 @@ void ClientCommand (edict_t *ent)
 			memcpy(&decoy->s,&ent->s,sizeof(entity_state_t));
 			decoy->s.number     = decoy-g_edicts;
 			decoy->s.frame      = ent->s.frame; 
-			AngleVectors(ent->client->v_angle,forward,NULL,NULL);
+			AngleVectors (ent->client->v_angle, forward, NULL, NULL);
-			VectorMA(ent->s.origin,64,forward,decoy->s.origin);
+			VectorMA (ent->s.origin, 64, forward, decoy->s.origin);
 			decoy->s.angles[YAW] = ent->s.angles[YAW]; 
 			decoy->takedamage   = DAMAGE_AIM;
 			decoy->flags        = (ent->flags & FL_NOTARGET);
@@ -2501,8 +2556,8 @@ void ClientCommand (edict_t *ent)
 			decoy->monsterinfo.aiflags = AI_GOOD_GUY;
 			decoy->die          = decoy_die;
 			decoy->nextthink    = level.time + FRAMETIME;
-			VectorCopy(ent->mins,decoy->mins);
+			VectorCopy (ent->mins, decoy->mins);
-			VectorCopy(ent->maxs,decoy->maxs);
+			VectorCopy (ent->maxs, decoy->maxs);
 			gi.linkentity (decoy); 
 		}
 		else if (!Q_stricmp(cmd, "switch"))
@@ -2510,7 +2565,7 @@ void ClientCommand (edict_t *ent)
 			extern mmove_t	actor_move_switch;
 			edict_t *viewing;
 
-			viewing = LookingAt(ent,0,NULL,NULL);
+			viewing = LookingAt(ent, 0, NULL, NULL);
 			if (!viewing)
 				return;
 			if (!(viewing->monsterinfo.aiflags & AI_ACTOR))
@@ -2520,8 +2575,29 @@ void ClientCommand (edict_t *ent)
 			}
 			viewing->monsterinfo.currentmove = &actor_move_switch;
 		}
-	//	else if (!Q_stricmp(cmd,"lightswitch"))
+		else if (!Q_stricmp(cmd, "resettargets"))
-	//		ToggleLights();
+		{
+			edict_t	*e;
+			int		i;
+			int		count;
+
+			gi.dprintf("Resetting all monsters' enemies...\n");
+			count = 0;
+			for (i=0, e=&g_edicts[0]; i<globals.num_edicts; i++, e++)
+			{
+				if (!e->inuse)
+					continue;
+				if ( !(e->svflags & SVF_MONSTER) )
+					continue;
+				if (e->health <= 0)
+					continue;
+				e->enemy = e->oldenemy = NULL;
+				e->monsterinfo.pausetime = 0;
+				e->monsterinfo.stand (e);
+				count++;
+			}
+			gi.dprintf("reset %d monsters' enemies, done.\n", count);
+		}
 		else	// anything that doesn't match a command will be a chat
 			Cmd_Say_f (ent, false, true);
 	}

missionpack/g_combat.c

@@ -429,7 +429,7 @@ void CallMyFriends (edict_t *targ, edict_t *attacker)
 					// Either target is not a monster, or attacker is not a monster, or
 					// they're both monsters but one is AI_GOOD_GUY and the other is not,
 					// or we've turned the game into a free-for-all with a target_monsterbattle
-					teammate = G_Find(NULL,FOFS(dmgteam),targ->dmgteam);
+					teammate = G_Find(NULL, FOFS(dmgteam), targ->dmgteam);
 					while (teammate)
 					{
 						if (teammate != targ)
@@ -457,7 +457,7 @@ void CallMyFriends (edict_t *targ, edict_t *attacker)
 							else if (!(teammate->svflags & SVF_DEADMONSTER))
 								G_UseTargets(teammate,attacker);
 						}
-						teammate = G_Find(teammate,FOFS(dmgteam),targ->dmgteam);
+						teammate = G_Find(teammate, FOFS(dmgteam), targ->dmgteam);
 					}
 				}
 			}
@@ -468,7 +468,7 @@ void CallMyFriends (edict_t *targ, edict_t *attacker)
 		// target is player; attacker is monster... alert "good guys", if any
 //		trace_t	tr;
 		edict_t	*teammate = NULL;
-		teammate = G_Find(NULL,FOFS(dmgteam),"player");
+		teammate = G_Find(NULL, FOFS(dmgteam), "player");
 		while (teammate)
 		{
 			if ((teammate->health > 0) && !(teammate->monsterinfo.aiflags & AI_CHASE_THING) && (teammate != attacker))
@@ -488,7 +488,7 @@ void CallMyFriends (edict_t *targ, edict_t *attacker)
 					}
 				}
 			}
-			teammate = G_Find(teammate,FOFS(dmgteam),"player");
+			teammate = G_Find(teammate, FOFS(dmgteam), "player");
 		}
 	}
 	// If player attacks a GOODGUY, turn GOODGUY stuff off
@@ -544,7 +544,7 @@ void M_ReactToDamage (edict_t *targ, edict_t *attacker, edict_t *inflictor)
 
 	// If targ is currently chasing a "thing" or we're running a hint_path test, he 
 	// doesn't really care what else is happening
-	if (targ->monsterinfo.aiflags & AI_CHASE_THING)
+	if ( (targ->monsterinfo.aiflags & AI_CHASE_THING) || (targ->monsterinfo.aiflags2 & AI2_HINT_TEST) )
 		return;
 
 	// If targ is a robot camera, ignore damage

missionpack/g_func_decs.h

@@ -2243,6 +2243,8 @@ extern qboolean blocked_checknewenemy ( edict_t * self ) ;
 extern qboolean blocked_checkjump ( edict_t * self , float dist , float maxDown , float maxUp ) ;
 extern qboolean blocked_checkplat ( edict_t * self , float dist ) ;
 extern qboolean blocked_checkshot ( edict_t * self , float shotChance ) ;
+extern int HintTestStart ( edict_t * self ) ;
+extern void HintTestNext ( edict_t * self , edict_t * hint ) ;
 extern int PatchMonsterModel ( char * modelname ) ;
 extern void InitiallyDead ( edict_t * self ) ;
 extern void monster_done_dodge ( edict_t * self ) ;
@@ -2534,8 +2536,8 @@ extern void SP_target_lock_digit ( edict_t * self ) ;
 extern void SP_target_lightswitch ( edict_t * self ) ;
 extern void use_target_lightswitch ( edict_t * self , edict_t * other , edict_t * activator ) ;
 extern void target_lightswitch_toggle ( edict_t * self ) ;
-extern void ToggleLights ( ) ;
+extern void ToggleLights ( void ) ;
-extern void Lights ( ) ;
+extern void Lights ( void ) ;
 extern void Jet_ApplyJet ( edict_t * ent , usercmd_t * ucmd ) ;
 extern void Jet_ApplySparks ( edict_t * ent ) ;
 extern void Jet_ApplyLifting ( edict_t * ent ) ;

missionpack/g_func_list.h

@@ -2243,6 +2243,8 @@
 {"blocked_checkjump", (byte *)blocked_checkjump},
 {"blocked_checkplat", (byte *)blocked_checkplat},
 {"blocked_checkshot", (byte *)blocked_checkshot},
+{"HintTestStart", (byte *)HintTestStart},
+{"HintTestNext", (byte *)HintTestNext},
 {"PatchMonsterModel", (byte *)PatchMonsterModel},
 {"InitiallyDead", (byte *)InitiallyDead},
 {"monster_done_dodge", (byte *)monster_done_dodge},

missionpack/g_lights.c

@@ -1,7 +1,7 @@
 #include "g_local.h"
 //==========================================================
 
-void Lights()
+void Lights (void)
 {
 	if (lights->value)
 	{
@@ -59,11 +59,11 @@ void Lights()
 	}
 }
 
-void ToggleLights()
+void ToggleLights (void)
 {
 	gi.cvar_set ("lights", va("%i", !lights->value));
 //	lights->value = !lights->value;
-	Lights();
+	Lights ();
 }
 
 void target_lightswitch_toggle (edict_t *self)

missionpack/g_local.h

@@ -1388,6 +1388,8 @@ void monster_fire_flechette (edict_t *self, vec3_t start, vec3_t dir, int damage
 void monster_fire_prox (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int damage_multiplier, int speed, int health, float timer, float damage_radius, int flashtype);
 // SKWiD MOD
 void monster_fire_plasma_rifle (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int flashtype, qboolean spread);
+void HintTestNext (edict_t *self, edict_t *hint);
+int  HintTestStart (edict_t *self);
 
 void M_droptofloor (edict_t *ent);
 void monster_think (edict_t *self);
@@ -1739,6 +1741,7 @@ void kick_attack (edict_t *ent);
 //
 // g_newweap.c
 //
+#define PROX_TEST_SIZE 7.0f
 //extern float nuke_framenum;
 void fire_flechette (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, float damage_radius, int radius_damage);
 //void fire_prox (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed);		

missionpack/g_monster.c

@@ -1120,9 +1120,10 @@ void M_MoveFrame (edict_t *self)
 
 	// Lazarus: For live monsters weaker than the tank who aren't already running from
 	//          something, evade live grenades on the ground.
-	if ((self->health > 0) && (self->max_health < 750) && !(self->monsterinfo.aiflags & AI_CHASE_THING) && self->monsterinfo.run)	// was self->max_health < 400
+/*	if ((self->health > 0) && (self->max_health < 750) && !(self->monsterinfo.aiflags & AI_CHASE_THING) && self->monsterinfo.run	// was self->max_health < 400
+		&& !((Q_stricmp(self->classname, "misc_insane") == 0) && (self->moreflags & FL2_CRUCIFIED)) )	// Knightmare- crucified insanes don't evade
 		Grenade_Evade (self);
-
+*/
 	move = self->monsterinfo.currentmove;
 	self->nextthink = level.time + FRAMETIME;
 
@@ -2676,3 +2677,121 @@ int PatchMonsterModel (char *modelname)
 	free (data);
 	return 1;
 }
+
+
+void HintTestNext (edict_t *self, edict_t *hint)
+{
+	edict_t		*next=NULL;
+	edict_t		*e;
+	vec3_t		dir;
+
+	self->monsterinfo.aiflags2 &= ~AI2_HINT_TEST;
+	if (self->goalentity == hint)
+		self->goalentity = NULL;
+	if (self->movetarget == hint)
+		self->movetarget = NULL;
+	if (self->monsterinfo.pathdir == 1)
+	{
+		if (hint->hint_chain)
+			next = hint->hint_chain;
+		else
+			self->monsterinfo.pathdir = -1;
+	}
+	if (self->monsterinfo.pathdir == -1)
+	{
+	//	e = hint_chain_starts[hint->hint_chain_id];
+		e = hint_path_start[hint->hint_chain_id];
+		while (e)
+		{
+			if (e->hint_chain == hint)
+			{
+				next = e;
+				break;
+			}
+			e = e->hint_chain;
+		}
+	}
+	if (!next)
+	{
+		self->monsterinfo.pathdir = 1;
+		next = hint->hint_chain;
+	}
+	if (next)
+	{
+		self->hint_chain_id = next->hint_chain_id;
+		VectorSubtract(next->s.origin, self->s.origin, dir);
+		self->ideal_yaw = vectoyaw(dir);
+		self->goalentity = self->movetarget = next;
+		self->monsterinfo.pausetime = 0;
+		self->monsterinfo.aiflags2 |= AI2_HINT_TEST;
+		// run for it
+		self->monsterinfo.run (self);
+		gi.dprintf("%s (%s): Reached hint_path %s,\nsearching for hint_path %s at %s. %s\n",
+			self->classname, (self->targetname ? self->targetname : "<noname>"),
+			(hint->targetname ? hint->targetname : "<noname>"),
+			(next->targetname ? next->targetname : "<noname>"),
+			vtos(next->s.origin),
+			(visible(self,next) ? "I see it." : "I don't see it."));
+	}
+	else
+	{
+		self->monsterinfo.pausetime = level.time + 100000000;
+		self->monsterinfo.stand (self);
+		gi.dprintf("%s (%s): Error finding next/previous hint_path from %s at %s.\n",
+			self->classname, (self->targetname ? self->targetname : "<noname>"),
+			(hint->targetname ? hint->targetname : "<noname>"),
+			vtos(hint->s.origin));
+	}
+}
+
+
+int HintTestStart (edict_t *self)
+{
+	edict_t	*e;
+	edict_t	*hint=NULL;
+	float	dist;
+	vec3_t	dir;
+	int		i;
+	float	bestdistance=99999;
+
+//	if (!hint_chains_exist)
+	if (!hint_paths_present)
+		return 0;
+
+	for (i=game.maxclients+1; i<globals.num_edicts; i++)
+	{
+			e = &g_edicts[i];
+			if (!e->inuse)
+				continue;
+			if (Q_stricmp(e->classname, "hint_path"))
+				continue;
+			if (!visible(self, e))
+				continue;
+			if (!canReach(self, e))
+				continue;
+			VectorSubtract (e->s.origin, self->s.origin, dir);
+			dist = VectorLength(dir);
+			if (dist < bestdistance)
+			{
+				hint = e;
+				bestdistance = dist;
+			}
+	}
+	if (hint)
+	{
+		self->hint_chain_id = hint->hint_chain_id;
+		if (!self->monsterinfo.pathdir)
+			self->monsterinfo.pathdir = 1;
+		VectorSubtract(hint->s.origin, self->s.origin, dir);
+		self->ideal_yaw = vectoyaw(dir);
+		self->enemy = self->oldenemy = NULL;
+		self->goalentity = self->movetarget = hint;
+		self->monsterinfo.pausetime = 0;
+		self->monsterinfo.aiflags2 = AI2_HINT_TEST;
+		// run for it
+		self->monsterinfo.run (self);
+		return 1;
+	}
+	else
+		return -1;
+}

missionpack/g_newai.c

@@ -167,8 +167,8 @@ qboolean blocked_checkplat (edict_t *self, float dist)
 			if ((self->groundentity == plat && plat->moveinfo.state == STATE_BOTTOM) ||
 				(self->groundentity != plat && plat->moveinfo.state == STATE_TOP))
 			{
-//				if (g_showlogic && g_showlogic->value)
+			//	if (g_showlogic && g_showlogic->value)
-//					gi.dprintf("player above, and plat will raise. using!\n");
+			//		gi.dprintf("player above, and plat will raise. using!\n");
 				plat->use (plat, self, self);
 				return true;			
 			}
@@ -178,14 +178,14 @@ qboolean blocked_checkplat (edict_t *self, float dist)
 			if ((self->groundentity == plat && plat->moveinfo.state == STATE_TOP) ||
 				(self->groundentity != plat && plat->moveinfo.state == STATE_BOTTOM))
 			{
-//				if (g_showlogic && g_showlogic->value)
+			//	if (g_showlogic && g_showlogic->value)
-//					gi.dprintf("player below, and plat will lower. using!\n");
+			//		gi.dprintf("player below, and plat will lower. using!\n");
 				plat->use (plat, self, self);
 				return true;
 			}
 		}
-//		if (g_showlogic && g_showlogic->value)
+	//	if (g_showlogic && g_showlogic->value)
-//			gi.dprintf("hit a plat, not using. ppos: %d   plat: %d\n", playerPosition, plat->moveinfo.state);
+	//		gi.dprintf("hit a plat, not using. ppos: %d   plat: %d\n", playerPosition, plat->moveinfo.state);
 	}
 
 	return false;
@@ -283,11 +283,11 @@ qboolean blocked_checkjump (edict_t *self, float dist, float maxDown, float maxU
 				gi.linkentity(self);
 				return true;
 			}
-//			else if (g_showlogic && g_showlogic->value)
+		//	else if (g_showlogic && g_showlogic->value)
-//				gi.dprintf("Too high to jump %0.1f\n", (trace.endpos[2] - self->absmin[2]));
+		//		gi.dprintf("Too high to jump %0.1f\n", (trace.endpos[2] - self->absmin[2]));
 		}
-//		else if (g_showlogic && g_showlogic->value)
+	//	else if (g_showlogic && g_showlogic->value)
-//				gi.dprintf("Not something I could jump onto\n");
+	//			gi.dprintf("Not something I could jump onto\n");
 	}
 //	else if (g_showlogic && g_showlogic->value)
 //		gi.dprintf("Player at similar level. No need to jump up?\n");
@@ -353,7 +353,7 @@ edict_t	*hintpath_findstart (edict_t *ent)
 {
 	edict_t		*e;
 	edict_t		*last;
-	int			field;
+	size_t		field;
 
 	if (ent->target)		// starting point
 	{
@@ -384,7 +384,7 @@ edict_t	*hintpath_findstart (edict_t *ent)
 
 	if (!(last->spawnflags & HINT_ENDPOINT))
 	{
-//		gi.dprintf ("end of chain is not HINT_ENDPOINT\n");
+	//	gi.dprintf ("end of chain is not HINT_ENDPOINT\n");
 		return NULL;
 	}
 
@@ -400,7 +400,7 @@ edict_t	*hintpath_other_end (edict_t *ent)
 {
 	edict_t		*e;
 	edict_t		*last;
-	int			field;
+	size_t		field;
 
 	if (ent->target)		// starting point
 	{
@@ -431,7 +431,7 @@ edict_t	*hintpath_other_end (edict_t *ent)
 
 	if (!(last->spawnflags & HINT_ENDPOINT))
 	{
-//		gi.dprintf ("end of chain is not HINT_ENDPOINT\n");
+	//	gi.dprintf ("end of chain is not HINT_ENDPOINT\n");
 		return NULL;
 	}
 
@@ -449,8 +449,8 @@ void hintpath_go (edict_t *self, edict_t *point)
 	vec3_t	dir;
 	vec3_t	angles;
 
-	VectorSubtract(point->s.origin, self->s.origin, dir);
+	VectorSubtract (point->s.origin, self->s.origin, dir);
-	vectoangles2(dir, angles);
+	vectoangles2 (dir, angles);
 
 	self->ideal_yaw = angles[YAW];
 	self->goalentity = self->movetarget = point;
@@ -509,7 +509,7 @@ qboolean monsterlost_checkhint (edict_t *self)
 	edict_t		*closest;
 	float		closest_range = 1000000;
 	edict_t		*start, *destination;
-	int			field;
+	size_t		field;
 	int			count1=0, count2=0, count3=0, count4=0, count5=0;
 	float		r;
 	int			i;
@@ -563,8 +563,8 @@ qboolean monsterlost_checkhint (edict_t *self)
 	{
 		r = realrange (self, e);
 
-//		if (r > 512)
+	//	if (r > 512)
-//			count3++;
+	//		count3++;
 
 		if (r > 512)
 		{
@@ -821,7 +821,7 @@ qboolean monsterlost_checkhint (edict_t *self)
 
 	self->monsterinfo.goal_hint = destination;
 //	self->monsterinfo.last_hint = NULL;
-	hintpath_go(self, start);
+	hintpath_go (self, start);
 
 	return true;
 }
@@ -829,7 +829,7 @@ qboolean monsterlost_checkhint (edict_t *self)
 qboolean monsterlost_checkhint2 (edict_t *self)
 {
 	edict_t		*e, *e2, *goPoint;
-	int			field;
+	size_t		field;
 	int			playerVisible, selfVisible;
 
 	// if there are no hint paths on this map, exit immediately.
@@ -926,7 +926,14 @@ void hint_path_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t
 	if (other->monsterinfo.aiflags & AI_MEDIC_PATROL) 
 	{
 		if (other->movetarget == self)
-			medic_NextPatrolPoint(other,self);
+			medic_NextPatrolPoint(other, self);
+		return;
+	}
+
+	if (other->monsterinfo.aiflags2 & AI2_HINT_TEST)
+	{
+		if (other->movetarget == self)
+			HintTestNext (other, self);
 		return;
 	}
 
@@ -975,7 +982,7 @@ void hint_path_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t
 
 		// set the last_hint entry to this hint_path, and
 		// send him on his way
-		hintpath_go(other, next);
+		hintpath_go (other, next);
 
 		// have the monster freeze if the hint path we just touched has a wait time
 		// on it, for example, when riding a plat.
@@ -1126,7 +1133,8 @@ void SP_hint_path (edict_t *self)
 void InitHintPaths (void)
 {
 	edict_t		*e, *current;
-	int			field, i, count2;
+	int			i, count2;
+	size_t		field;
 	qboolean	errors = false;
 
 	hint_paths_present = 0;

missionpack/g_weapon.c

@@ -943,8 +943,8 @@ qboolean AimGrenade (edict_t *self, vec3_t start, vec3_t target, vec_t speed, ve
 	int			i;
 	vec3_t		last_aim;
 	// Knightmare- wider bounds to avoid prox collision
-	vec3_t		proxMins = {-8, -8, -8};
+	vec3_t		proxMins = {-PROX_TEST_SIZE, -PROX_TEST_SIZE, -PROX_TEST_SIZE};
-	vec3_t		proxMaxs = {8, 8, 8};
+	vec3_t		proxMaxs = {PROX_TEST_SIZE, PROX_TEST_SIZE, PROX_TEST_SIZE};
 
 	VectorCopy (target, aim_point);
 	VectorSubtract (aim_point, self->s.origin, from_origin);

missionpack/m_gunner.c

@@ -431,19 +431,20 @@ void gunner_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damag
 // Knightmare added
 // This calcs horizontal spread of prox mines based on distance.
 // Then it does a short-range trace at blast radius, to ensure we won't clip a wall.
+#define GUNNER_PROX_DANGER_RANGE	256.0f
 qboolean gunner_prox_safety_check (edict_t *self, vec3_t start, vec3_t target)
 {
 	trace_t		tr;
 	vec3_t		closeCheckMins, closeCheckMaxs, dir, dangerOffset, dangerTarget;
-	float		dist, dangerSpread, dangerRange = 256.0f;
+	float		dist, dangerSpread;
 
 	// get dist to target
 	VectorSubtract (target, start, dir);
 	dist = VectorLength (dir);
 
 	// get spread at damger range
-	dangerSpread = (HALF_GUNNER_PROX_SPREAD / dist) * dangerRange;
+	dangerSpread = (HALF_GUNNER_PROX_SPREAD / dist) * GUNNER_PROX_DANGER_RANGE;
-	dangerSpread += 8.0f;	// add bounds of prox mine + 2
+	dangerSpread += PROX_TEST_SIZE;	// add bounds of prox mine + 1
 	VectorSet (closeCheckMins, -dangerSpread, -dangerSpread, -12.0f);
 	VectorSet (closeCheckMaxs, dangerSpread, dangerSpread, 12.0f);
 
@@ -452,7 +453,7 @@ qboolean gunner_prox_safety_check (edict_t *self, vec3_t start, vec3_t target)
 
 	// extrapolate point on path to target at danger range
 	VectorNormalize (dir);
-	VectorScale (dir, dangerRange, dangerOffset);
+	VectorScale (dir, GUNNER_PROX_DANGER_RANGE, dangerOffset);
 	VectorAdd (start, dangerOffset, dangerTarget);
 
 	tr = gi.trace(start, closeCheckMins, closeCheckMaxs, dangerTarget, self, MASK_SHOT);
@@ -479,8 +480,8 @@ qboolean gunner_grenade_check (edict_t *self)
 	// Knightmare- Tactician Gunner fires prox mines in a spread, 
 	// so we need a wider safety bounds check
 	vec3_t		checkMins, checkMaxs;
-	vec3_t		proxMins = {-8, -8, -8};
+	vec3_t		proxMins = {-PROX_TEST_SIZE, -PROX_TEST_SIZE, -PROX_TEST_SIZE};
-	vec3_t		proxMaxs = {8, 8, 8};
+	vec3_t		proxMaxs = {PROX_TEST_SIZE, PROX_TEST_SIZE, PROX_TEST_SIZE};
 
 	if (!self->enemy)
 		return false;

missionpack/m_medic.c

@@ -415,7 +415,7 @@ void medic_idle (edict_t *self)
 	{
 		// Then we must have reached this point after losing sight
 		// of our patient.
-		abortHeal(self,false,false,false);
+		abortHeal (self, false, false, false);
 	}
 
 /*	if (!self->oldenemy)

missionpack/z_hound.c

@@ -648,6 +648,12 @@ void SP_monster_hound (edict_t *self)
 	gi.linkentity (self);
 
 	self->monsterinfo.currentmove = &hound_stand1;	
+	if (self->health < 0)
+	{
+		mmove_t	*deathmoves[] = {&hound_move_death,
+								 NULL};
+		M_SetDeath (self, (mmove_t **)&deathmoves);
+	}
 	self->monsterinfo.scale = MODEL_SCALE;
 
 	walkmonster_start (self);

missionpack/z_sentien.c

@@ -1308,6 +1308,13 @@ void SP_monster_sentien (edict_t *self)
 	}
 
 	self->monsterinfo.currentmove = &sentien_move_stand1;
+	if (self->health < 0)
+	{
+		mmove_t	*deathmoves[] = {&sentien_move_death1,
+			                     &sentien_move_death2,
+								 NULL};
+		M_SetDeath (self, (mmove_t **)&deathmoves);
+	}
 	self->monsterinfo.scale = MODEL_SCALE;
 
 	walkmonster_start(self);

renderer/r_alias.c

@@ -553,7 +553,7 @@ void R_DrawAliasMeshes (maliasmodel_t *paliashdr, entity_t *e, qboolean mirrored
 		}
 
 		if (!shellModel)
-			RB_ModifyTextureCoords (&texCoordArray[0][baseindex][0], &vertexArray[baseindex][0], mesh.num_verts, &skinParms);
+			RB_ModifyTextureCoords (&texCoordArray[0][baseindex][0], &vertexArray[baseindex][0], mesh.num_verts, &skinParms.tcmod);
 
 		// compare renderparms for next mesh and check for overflow
 		if ( k < (paliashdr->num_meshes-1) ) {

renderer/r_alias.h

@@ -68,16 +68,8 @@ typedef struct
 	float			params[4];
 } waveFunc_t;
 
-typedef struct 
+typedef struct
 {
-	qboolean		twosided;
-	qboolean		alphatest;
-	qboolean		fullbright;
-	qboolean		nodraw;
-	qboolean		noshadow;
-	qboolean		nodiffuse;
-	float			envmap;
-	float			basealpha;
 	float			translate_x;
 	float			translate_y;
 	float			rotate;
@@ -87,7 +79,20 @@ typedef struct
 	waveFunc_t		turb;
 	float			scroll_x;
 	float			scroll_y;
+} tcmodParms_t;
+
+typedef struct 
+{
+	qboolean		twosided;
+	qboolean		alphatest;
+	qboolean		fullbright;
+	qboolean		nodraw;
+	qboolean		noshadow;
+	qboolean		nodiffuse;
 	qboolean		blend;
+	tcmodParms_t	tcmod;
+	float			envmap;
+	float			basealpha;
 	GLenum			blendfunc_src;
 	GLenum			blendfunc_dst;
 	waveFunc_t		glow;

renderer/r_backend.c

@@ -146,7 +146,7 @@ RB_ModifyTextureCoords
 borrowed from EGL & Q2E
 =================
 */
-void RB_ModifyTextureCoords (float *inArray, float *inVerts, int numVerts, renderparms_t *parms)
+void RB_ModifyTextureCoords (float *inArray, float *inVerts, int numVerts, tcmodParms_t *parms)
 {
 	int		i;
 	float	t1, t2, sint, cost, rad;

renderer/r_draw.c

@@ -320,6 +320,7 @@ image_t	*R_DrawFindPic (char *name)
 	return gl;
 }
 
+
 /*
 =============
 R_DrawGetPicSize
@@ -343,27 +344,22 @@ void R_DrawGetPicSize (int *w, int *h, char *pic)
 
 /*
 =============
-R_DrawStretchPic
+R_DrawPic_Standard
+Actual pic drawing code.
+Not to be called from other sections.
 =============
 */
-void R_DrawStretchPic (int x, int y, int w, int h, char *pic, float alpha)
+void R_DrawPic_Standard (int x, int y, int w, int h, vec2_t offset, vec4_t stCoords, vec4_t color, int texnum, renderparms_t *parms, qboolean texClamp)
 {
-	image_t		*gl;
 	int			i;
 	vec2_t		texCoord[4], verts[4];
 
-	gl = R_DrawFindPic (pic);
+	if (!parms)	return;
-	if (!gl)
-	{
-		VID_Printf (PRINT_ALL, "Can't find pic: %s\n", pic);
-		return;
-	}
 
 	if (scrap_dirty)
 		Scrap_Upload ();
 
-	// Psychospaz's transparent console support
+	if (parms->blend)
-	if (gl->has_alpha || alpha < 1.0)
 	{
 		GL_Disable (GL_ALPHA_TEST);
 		GL_TexEnv (GL_MODULATE);
@@ -371,17 +367,24 @@ void R_DrawStretchPic (int x, int y, int w, int h, char *pic, float alpha)
 		GL_DepthMask (false);
 	}
 
-	GL_Bind (gl->texnum);
+	GL_Bind (texnum);
 
-	Vector2Set(texCoord[0], gl->sl, gl->tl);
+	if (texClamp) {
-	Vector2Set(texCoord[1], gl->sh, gl->tl);
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
-	Vector2Set(texCoord[2], gl->sh, gl->th);
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
-	Vector2Set(texCoord[3], gl->sl, gl->th);
+	}
 
-	Vector2Set(verts[0], x, y);
+	Vector2Set(texCoord[0], stCoords[0], stCoords[1]);
-	Vector2Set(verts[1], x+w, y);
+	Vector2Set(texCoord[1], stCoords[2], stCoords[1]);
-	Vector2Set(verts[2], x+w, y+h);
+	Vector2Set(texCoord[2], stCoords[2], stCoords[3]);
-	Vector2Set(verts[3], x, y+h);
+	Vector2Set(texCoord[3], stCoords[0], stCoords[3]);
+
+	Vector2Set(verts[0], x+offset[0], y+offset[1]);
+	Vector2Set(verts[1], x+w+offset[0], y-offset[1]);
+	Vector2Set(verts[2], x+w-offset[0], y+h-offset[1]);
+	Vector2Set(verts[3], x-offset[0], y+h+offset[1]);
+
+	RB_ModifyTextureCoords (&texCoord[0][0], &verts[0][0], 4, &parms->tcmod);
 
 	rb_vertex = rb_index = 0;
 	indexArray[rb_index++] = rb_vertex+0;
@@ -391,15 +394,19 @@ void R_DrawStretchPic (int x, int y, int w, int h, char *pic, float alpha)
 	indexArray[rb_index++] = rb_vertex+2;
 	indexArray[rb_index++] = rb_vertex+3;
 	for (i=0; i<4; i++) {
-		VA_SetElem2(texCoordArray[0][rb_vertex], texCoord[i][0], texCoord[i][1]);
+		VA_SetElem2v(texCoordArray[0][rb_vertex], texCoord[i]);
 		VA_SetElem3(vertexArray[rb_vertex], verts[i][0], verts[i][1], 0);
-		VA_SetElem4(colorArray[rb_vertex], 1.0, 1.0, 1.0, alpha);
+		VA_SetElem4v(colorArray[rb_vertex], color);
 		rb_vertex++;
 	}
 	RB_RenderMeshGeneric (false);
 
-	// Psychospaz's transparent console support
+	if (texClamp) {
-	if (gl->has_alpha || alpha < 1.0)
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+	}
+
+	if (parms->blend)
 	{
 		GL_DepthMask (true);
 		GL_TexEnv (GL_REPLACE);
@@ -411,55 +418,75 @@ void R_DrawStretchPic (int x, int y, int w, int h, char *pic, float alpha)
 
 /*
 =============
-R_DrawScaledPic
+R_DrawPic_Masked
-Psychospaz's code for drawing stretched crosshairs
 =============
 */
-void R_DrawScaledPic (int x, int y, float scale, float alpha, char *pic)
+void R_DrawPic_Masked (int x, int y, int w, int h, vec2_t offset, vec4_t stCoords, vec4_t color, int texnum, int maskTexnum, renderparms_t *parms, qboolean texClamp)
 {
-	float	xoff, yoff;
+	int			i;
-	float	scale_x, scale_y;
+	vec2_t		texCoord[4], scrollTexCoord[4], verts[4];
-	image_t *gl;
-	int		i;
-	vec2_t	texCoord[4], verts[4];
 
-	gl = R_DrawFindPic (pic);
+	if (!parms)	return;
-
-	if (!gl) {
-		VID_Printf (PRINT_ALL, "Can't find pic: %s\n", pic);
-		return;
-	}
 
 	if (scrap_dirty)
 		Scrap_Upload ();
 
-	// add alpha support
+	if (parms->blend)
-	if (gl->has_alpha || alpha < 1.0)
 	{
 		GL_Disable (GL_ALPHA_TEST);
-		GL_TexEnv (GL_MODULATE);
 		GL_Enable (GL_BLEND);
+	//	GL_BlendFunc (GL_SRC_ALPHA, additive ? GL_ONE : GL_ONE_MINUS_SRC_ALPHA);	// GL_DST_ALPHA, GL_ONE
+		GL_BlendFunc (parms->blendfunc_src, parms->blendfunc_dst);
 		GL_DepthMask (false);
 	}
 
-	GL_Bind (gl->texnum);
+	GL_SelectTexture (0);
+	GL_Bind (maskTexnum);
+	GL_TexEnv (GL_COMBINE_ARB);
 
-	scale_x = scale_y = scale;
+	// Do nothing with this stage, it's just for alpha
-	scale_x *= gl->replace_scale_w; // scale down if replacing a pcx image
+	qglTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_INTERPOLATE);
-	scale_y *= gl->replace_scale_h; // scale down if replacing a pcx image
+	qglTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB);
+	qglTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
+	qglTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_INTERPOLATE);
+	qglTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE);
+	qglTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_TEXTURE);
 
-	Vector2Set(texCoord[0], gl->sl, gl->tl);
+	GL_EnableTexture (1);
-	Vector2Set(texCoord[1], gl->sh, gl->tl);
+	GL_Bind (texnum);
-	Vector2Set(texCoord[2], gl->sh, gl->th);
+	GL_TexEnv (GL_COMBINE_ARB);
-	Vector2Set(texCoord[3], gl->sl, gl->th);
 
-	xoff = gl->width*scale_x-gl->width;
+	if (texClamp) {
-	yoff = gl->height*scale_y-gl->height;
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+	}
 
-	Vector2Set(verts[0], x, y);
+	// This stage uses the previous one's alpha value
-	Vector2Set(verts[1], x+gl->width+xoff, y);
+	if (parms->blend) {
-	Vector2Set(verts[2], x+gl->width+xoff, y+gl->height+yoff);
+		qglTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
-	Vector2Set(verts[3], x, y+gl->height+yoff);
+		qglTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE);
+	}
+	else {
+		qglTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
+		qglTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
+	}
+	qglTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
+	qglTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE0);	// GL_PREVIOUS_ARB
+
+	Vector2Set(texCoord[0], stCoords[0], stCoords[1]);
+	Vector2Set(texCoord[1], stCoords[2], stCoords[1]);
+	Vector2Set(texCoord[2], stCoords[2], stCoords[3]);
+	Vector2Set(texCoord[3], stCoords[0], stCoords[3]);
+
+	for (i=0; i<4; i++)
+		Vector2Copy(texCoord[i], scrollTexCoord[i]);
+
+	Vector2Set(verts[0], x+offset[0], y+offset[1]);
+	Vector2Set(verts[1], x+w+offset[0], y-offset[1]);
+	Vector2Set(verts[2], x+w-offset[0], y+h-offset[1]);
+	Vector2Set(verts[3], x-offset[0], y+h+offset[1]);
+
+	RB_ModifyTextureCoords (&scrollTexCoord[0][0], &verts[0][0], 4, &parms->tcmod);
 
 	rb_vertex = rb_index = 0;
 	indexArray[rb_index++] = rb_vertex+0;
@@ -469,19 +496,36 @@ void R_DrawScaledPic (int x, int y, float scale, float alpha, char *pic)
 	indexArray[rb_index++] = rb_vertex+2;
 	indexArray[rb_index++] = rb_vertex+3;
 	for (i=0; i<4; i++) {
-		VA_SetElem2(texCoordArray[0][rb_vertex], texCoord[i][0], texCoord[i][1]);
+		VA_SetElem2v(texCoordArray[0][rb_vertex], texCoord[i]);
+		VA_SetElem2v(texCoordArray[1][rb_vertex], scrollTexCoord[i]);
 		VA_SetElem3(vertexArray[rb_vertex], verts[i][0], verts[i][1], 0);
-		VA_SetElem4(colorArray[rb_vertex], 1.0, 1.0, 1.0, alpha);
+		VA_SetElem4v(colorArray[rb_vertex], color);
 		rb_vertex++;
 	}
 	RB_RenderMeshGeneric (false);
 
-	if (gl->has_alpha || alpha < 1.0)
+	if (texClamp) {
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+	}
+
+	// Reset parms
+	GL_DisableTexture (1);
+	GL_SelectTexture (0);
+	qglTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
+	qglTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
+	qglTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
+	qglTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
+	qglTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE);
+	qglTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_PREVIOUS_ARB);
+	GL_TexEnv (GL_REPLACE);
+
+	if (parms->blend)
 	{
 		GL_DepthMask (true);
-		GL_TexEnv (GL_REPLACE);
+		GL_BlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 		GL_Disable (GL_BLEND);
-		GL_Enable (GL_ALPHA_TEST); // add alpha support
+		GL_Enable (GL_ALPHA_TEST);
 	}
 }
 
@@ -491,102 +535,62 @@ void R_DrawScaledPic (int x, int y, float scale, float alpha, char *pic)
 R_DrawPic
 =============
 */
-void R_DrawPic (int x, int y, char *pic)
+void R_DrawPic (drawStruct_t ds)	
 {
-	image_t	*gl;
+	int				w, h;
-	int		i;
+	float			scale_x, scale_y;
-	vec2_t	texCoord[4], verts[4];
+	vec4_t			texCoords;
-
+	image_t			*image;
-	gl = R_DrawFindPic (pic);
+	renderparms_t	drawParms;
-
-	if (!gl) {
-		VID_Printf (PRINT_ALL, "Can't find pic: %s\n", pic);
-		return;
-	}
-
-	if (scrap_dirty)
-		Scrap_Upload ();
-
-	GL_Bind (gl->texnum);
-
-	Vector2Set(texCoord[0], gl->sl, gl->tl);
-	Vector2Set(texCoord[1], gl->sh, gl->tl);
-	Vector2Set(texCoord[2], gl->sh, gl->th);
-	Vector2Set(texCoord[3], gl->sl, gl->th);
-
-	Vector2Set(verts[0], x, y);
-	Vector2Set(verts[1], x+gl->width, y);
-	Vector2Set(verts[2], x+gl->width, y+gl->height);
-	Vector2Set(verts[3], x, y+gl->height);
-
-	rb_vertex = rb_index = 0;
-	indexArray[rb_index++] = rb_vertex+0;
-	indexArray[rb_index++] = rb_vertex+1;
-	indexArray[rb_index++] = rb_vertex+2;
-	indexArray[rb_index++] = rb_vertex+0;
-	indexArray[rb_index++] = rb_vertex+2;
-	indexArray[rb_index++] = rb_vertex+3;
-	for (i=0; i<4; i++) {
-		VA_SetElem2(texCoordArray[0][rb_vertex], texCoord[i][0], texCoord[i][1]);
-		VA_SetElem3(vertexArray[rb_vertex], verts[i][0], verts[i][1], 0);
-		VA_SetElem4(colorArray[rb_vertex], 1.0, 1.0, 1.0, 1.0);
-		rb_vertex++;
-	}
-	RB_RenderMeshGeneric (false);
-}
-
-/*
-=============
-R_DrawTileClear
-
-This repeats a 64*64 tile graphic to fill the screen around a sized down
-refresh window.
-=============
-*/
-void R_DrawTileClear (int x, int y, int w, int h, char *pic)
-{
-	image_t	*image;
-	int		i;
-	vec2_t	texCoord[4], verts[4];
-
-	image = R_DrawFindPic (pic);
 
+	image = R_DrawFindPic (ds.pic);
 	if (!image) {
-		VID_Printf (PRINT_ALL, "Can't find pic: %s\n", pic);
+		VID_Printf (PRINT_ALL, "Can't find pic: %s\n", ds.pic);
 		return;
 	}
 
-	GL_Bind (image->texnum);
+	w = ds.w;	h = ds.h;
-/*
+	if (ds.flags & DSFLAG_USESTCOORDS)	// use passed coords
-	Vector2Set(texCoord[0], x/64.0, y/64.0);
+		Vector4Copy (ds.stCoords, texCoords);
-	Vector2Set(texCoord[1], (x+w)/64.0, y/64.0);
+	else if (ds.flags & DSFLAG_TILED)	// use tiled coords
-	Vector2Set(texCoord[2], (x+w)/64.0, (y+h)/64.0);
+		Vector4Set (texCoords, (float)ds.x/(float)image->width, (float)ds.y/(float)image->height,
-	Vector2Set(texCoord[3], x/64.0, (y+h)/64.0);
+					(float)(ds.x+ds.w)/(float)image->width, (float)(ds.y+ds.h)/(float)image->height);
-*/
+	else if (ds.flags & DSFLAG_SCALED)	// use scaled size
-	Vector2Set(texCoord[0], (float)x/(float)image->width, (float)y/(float)image->height);
+	{
-	Vector2Set(texCoord[1], (float)(x+w)/(float)image->width, (float)y/(float)image->height);
+		Vector4Set (texCoords, image->sl, image->tl, image->sh, image->th);
-	Vector2Set(texCoord[2], (float)(x+w)/(float)image->width, (float)(y+h)/(float)image->height);
-	Vector2Set(texCoord[3], (float)x/(float)image->width, (float)(y+h)/(float)image->height);
 
-	Vector2Set(verts[0], x, y);
+		scale_x = ds.scale[0];
-	Vector2Set(verts[1], x+w, y);
+		scale_y = ds.scale[1];
-	Vector2Set(verts[2], x+w, y+h);
+		scale_x *= image->replace_scale_w;	// scale down if replacing a pcx image
-	Vector2Set(verts[3], x, y+h);
+		scale_y *= image->replace_scale_h;	// scale down if replacing a pcx image
-
+		w = image->width*scale_x;
-	rb_vertex = rb_index = 0;
+		h = image->height*scale_y;
-	indexArray[rb_index++] = rb_vertex+0;
-	indexArray[rb_index++] = rb_vertex+1;
-	indexArray[rb_index++] = rb_vertex+2;
-	indexArray[rb_index++] = rb_vertex+0;
-	indexArray[rb_index++] = rb_vertex+2;
-	indexArray[rb_index++] = rb_vertex+3;
-	for (i=0; i<4; i++) {
-		VA_SetElem2(texCoordArray[0][rb_vertex], texCoord[i][0], texCoord[i][1]);
-		VA_SetElem3(vertexArray[rb_vertex], verts[i][0], verts[i][1], 0);
-		VA_SetElem4(colorArray[rb_vertex], 1.0, 1.0, 1.0, 1.0);
-		rb_vertex++;
 	}
-	RB_RenderMeshGeneric (false);
+	else	// use internal coords
+		Vector4Set (texCoords, image->sl, image->tl, image->sh, image->th);
+
+	Mod_SetRenderParmsDefaults (&drawParms);
+	drawParms.tcmod.scroll_x = ds.scroll[0];
+	drawParms.tcmod.scroll_y = ds.scroll[1];
+
+	// masked image option
+	if ( (ds.flags & DSFLAG_MASKED) && (ds.maskPic != NULL) && glConfig.mtexcombine )
+	{
+		image_t		*maskImage = R_DrawFindPic (ds.maskPic);
+
+		if (maskImage != NULL)
+		{
+		//	VID_Printf (PRINT_ALL, "Drawing pic with mask: %s\n", pic);
+			drawParms.blend = true;
+			drawParms.blendfunc_src = GL_SRC_ALPHA;
+			drawParms.blendfunc_dst = GL_ONE;
+			R_DrawPic_Masked (ds.x, ds.y, w, h, ds.offset, ds.stCoords, ds.color, image->texnum, maskImage->texnum, &drawParms, (ds.flags & DSFLAG_CLAMP));
+			return;
+		}
+	}
+
+	drawParms.blend = (image->has_alpha || ds.color[3] < 1.0f);
+	R_DrawPic_Standard (ds.x, ds.y, w, h, ds.offset, texCoords, ds.color, image->texnum, &drawParms, (ds.flags & DSFLAG_CLAMP));
 }
 
 
@@ -608,7 +612,6 @@ void R_DrawFill (int x, int y, int w, int h, int red, int green, int blue, int a
 	blue = min(blue, 255);
 	alpha = max(min(alpha, 255), 1);
 
-//	GL_DisableTexture (0);
 	GL_Disable (GL_ALPHA_TEST);
 	GL_TexEnv (GL_MODULATE);
 	GL_Enable (GL_BLEND);
@@ -651,8 +654,6 @@ R_DrawCameraEffect
 Video camera effect
 =============
 */
-void Mod_SetRenderParmsDefaults (renderparms_t *parms);
-
 void R_DrawCameraEffect (void)
 {
 	image_t			*image[2];
@@ -660,7 +661,7 @@ void R_DrawCameraEffect (void)
 	float			texparms[2][4];
 	vec2_t			texCoord[4];
 	vec3_t			verts[4];
-	renderparms_t	cameraParms;
+	tcmodParms_t	cameraParms;
 
 	image[0] = R_DrawFindPic ("/gfx/2d/screenstatic.tga");
 	image[1] = R_DrawFindPic ("/gfx/2d/scanlines.tga");
@@ -699,7 +700,7 @@ void R_DrawCameraEffect (void)
 		Vector2Set(texCoord[1], (x+w)/image[i]->width, y/image[i]->height);
 		Vector2Set(texCoord[2], (x+w)/image[i]->width, (y+h)/image[i]->height);
 		Vector2Set(texCoord[3], x/image[i]->width, (y+h)/image[i]->height);
-		Mod_SetRenderParmsDefaults (&cameraParms);
+		Mod_SetTCModParmsDefaults (&cameraParms);
 		cameraParms.scale_x = texparms[i][0];
 		cameraParms.scale_y = texparms[i][1];
 		cameraParms.scroll_x = texparms[i][2];

renderer/r_draw_removed.c

@@ -0,0 +1,277 @@
+/*
+===========================================================================
+Copyright (C) 1997-2001 Id Software, Inc.
+
+This file is part of Quake 2 source code.
+
+Quake 2 source code is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 2 of the License,
+or (at your option) any later version.
+
+Quake 2 source code is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Quake 2 source code; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+===========================================================================
+*/
+
+// r_draw_removed.c - various removed pic drawing functions
+
+#include "r_local.h"
+
+#if 0
+
+/*
+=============
+R_DrawStretchPic
+=============
+*/
+void R_DrawStretchPic (int x, int y, int w, int h, char *pic, float alpha)
+{
+	image_t		*gl;
+	int			i;
+	vec2_t		texCoord[4], verts[4];
+
+	gl = R_DrawFindPic (pic);
+	if (!gl)
+	{
+		VID_Printf (PRINT_ALL, "Can't find pic: %s\n", pic);
+		return;
+	}
+
+	if (scrap_dirty)
+		Scrap_Upload ();
+
+	// Psychospaz's transparent console support
+	if (gl->has_alpha || alpha < 1.0)
+	{
+		GL_Disable (GL_ALPHA_TEST);
+		GL_TexEnv (GL_MODULATE);
+		GL_Enable (GL_BLEND);
+		GL_DepthMask (false);
+	}
+
+	GL_Bind (gl->texnum);
+
+	Vector2Set(texCoord[0], gl->sl, gl->tl);
+	Vector2Set(texCoord[1], gl->sh, gl->tl);
+	Vector2Set(texCoord[2], gl->sh, gl->th);
+	Vector2Set(texCoord[3], gl->sl, gl->th);
+
+	Vector2Set(verts[0], x, y);
+	Vector2Set(verts[1], x+w, y);
+	Vector2Set(verts[2], x+w, y+h);
+	Vector2Set(verts[3], x, y+h);
+
+	rb_vertex = rb_index = 0;
+	indexArray[rb_index++] = rb_vertex+0;
+	indexArray[rb_index++] = rb_vertex+1;
+	indexArray[rb_index++] = rb_vertex+2;
+	indexArray[rb_index++] = rb_vertex+0;
+	indexArray[rb_index++] = rb_vertex+2;
+	indexArray[rb_index++] = rb_vertex+3;
+	for (i=0; i<4; i++) {
+		VA_SetElem2(texCoordArray[0][rb_vertex], texCoord[i][0], texCoord[i][1]);
+		VA_SetElem3(vertexArray[rb_vertex], verts[i][0], verts[i][1], 0);
+		VA_SetElem4(colorArray[rb_vertex], 1.0, 1.0, 1.0, alpha);
+		rb_vertex++;
+	}
+	RB_RenderMeshGeneric (false);
+
+	// Psychospaz's transparent console support
+	if (gl->has_alpha || alpha < 1.0)
+	{
+		GL_DepthMask (true);
+		GL_TexEnv (GL_REPLACE);
+		GL_Disable (GL_BLEND);
+		GL_Enable (GL_ALPHA_TEST);
+	}
+}
+
+
+/*
+=============
+R_DrawScaledPic
+Psychospaz's code for drawing stretched crosshairs
+=============
+*/
+void R_DrawScaledPic (int x, int y, float scale, float alpha, char *pic)
+{
+	float	xoff, yoff;
+	float	scale_x, scale_y;
+	image_t *gl;
+	int		i;
+	vec2_t	texCoord[4], verts[4];
+
+	gl = R_DrawFindPic (pic);
+
+	if (!gl) {
+		VID_Printf (PRINT_ALL, "Can't find pic: %s\n", pic);
+		return;
+	}
+
+	if (scrap_dirty)
+		Scrap_Upload ();
+
+	// add alpha support
+	if (gl->has_alpha || alpha < 1.0)
+	{
+		GL_Disable (GL_ALPHA_TEST);
+		GL_TexEnv (GL_MODULATE);
+		GL_Enable (GL_BLEND);
+		GL_DepthMask (false);
+	}
+
+	GL_Bind (gl->texnum);
+
+	scale_x = scale_y = scale;
+	scale_x *= gl->replace_scale_w; // scale down if replacing a pcx image
+	scale_y *= gl->replace_scale_h; // scale down if replacing a pcx image
+
+	Vector2Set(texCoord[0], gl->sl, gl->tl);
+	Vector2Set(texCoord[1], gl->sh, gl->tl);
+	Vector2Set(texCoord[2], gl->sh, gl->th);
+	Vector2Set(texCoord[3], gl->sl, gl->th);
+
+	xoff = gl->width*scale_x-gl->width;
+	yoff = gl->height*scale_y-gl->height;
+
+	Vector2Set(verts[0], x, y);
+	Vector2Set(verts[1], x+gl->width+xoff, y);
+	Vector2Set(verts[2], x+gl->width+xoff, y+gl->height+yoff);
+	Vector2Set(verts[3], x, y+gl->height+yoff);
+
+	rb_vertex = rb_index = 0;
+	indexArray[rb_index++] = rb_vertex+0;
+	indexArray[rb_index++] = rb_vertex+1;
+	indexArray[rb_index++] = rb_vertex+2;
+	indexArray[rb_index++] = rb_vertex+0;
+	indexArray[rb_index++] = rb_vertex+2;
+	indexArray[rb_index++] = rb_vertex+3;
+	for (i=0; i<4; i++) {
+		VA_SetElem2(texCoordArray[0][rb_vertex], texCoord[i][0], texCoord[i][1]);
+		VA_SetElem3(vertexArray[rb_vertex], verts[i][0], verts[i][1], 0);
+		VA_SetElem4(colorArray[rb_vertex], 1.0, 1.0, 1.0, alpha);
+		rb_vertex++;
+	}
+	RB_RenderMeshGeneric (false);
+
+	if (gl->has_alpha || alpha < 1.0)
+	{
+		GL_DepthMask (true);
+		GL_TexEnv (GL_REPLACE);
+		GL_Disable (GL_BLEND);
+		GL_Enable (GL_ALPHA_TEST); // add alpha support
+	}
+}
+
+
+/*
+=============
+R_DrawPic
+=============
+*/
+void R_DrawPic (int x, int y, char *pic)
+{
+	image_t	*gl;
+	int		i;
+	vec2_t	texCoord[4], verts[4];
+
+	gl = R_DrawFindPic (pic);
+
+	if (!gl) {
+		VID_Printf (PRINT_ALL, "Can't find pic: %s\n", pic);
+		return;
+	}
+
+	if (scrap_dirty)
+		Scrap_Upload ();
+
+	GL_Bind (gl->texnum);
+
+	Vector2Set(texCoord[0], gl->sl, gl->tl);
+	Vector2Set(texCoord[1], gl->sh, gl->tl);
+	Vector2Set(texCoord[2], gl->sh, gl->th);
+	Vector2Set(texCoord[3], gl->sl, gl->th);
+
+	Vector2Set(verts[0], x, y);
+	Vector2Set(verts[1], x+gl->width, y);
+	Vector2Set(verts[2], x+gl->width, y+gl->height);
+	Vector2Set(verts[3], x, y+gl->height);
+
+	rb_vertex = rb_index = 0;
+	indexArray[rb_index++] = rb_vertex+0;
+	indexArray[rb_index++] = rb_vertex+1;
+	indexArray[rb_index++] = rb_vertex+2;
+	indexArray[rb_index++] = rb_vertex+0;
+	indexArray[rb_index++] = rb_vertex+2;
+	indexArray[rb_index++] = rb_vertex+3;
+	for (i=0; i<4; i++) {
+		VA_SetElem2(texCoordArray[0][rb_vertex], texCoord[i][0], texCoord[i][1]);
+		VA_SetElem3(vertexArray[rb_vertex], verts[i][0], verts[i][1], 0);
+		VA_SetElem4(colorArray[rb_vertex], 1.0, 1.0, 1.0, 1.0);
+		rb_vertex++;
+	}
+	RB_RenderMeshGeneric (false);
+}
+
+/*
+=============
+R_DrawTileClear
+
+This repeats a 64*64 tile graphic to fill the screen around a sized down
+refresh window.
+=============
+*/
+void R_DrawTileClear (int x, int y, int w, int h, char *pic)
+{
+	image_t	*image;
+	int		i;
+	vec2_t	texCoord[4], verts[4];
+
+	image = R_DrawFindPic (pic);
+
+	if (!image) {
+		VID_Printf (PRINT_ALL, "Can't find pic: %s\n", pic);
+		return;
+	}
+
+	GL_Bind (image->texnum);
+/*
+	Vector2Set(texCoord[0], x/64.0, y/64.0);
+	Vector2Set(texCoord[1], (x+w)/64.0, y/64.0);
+	Vector2Set(texCoord[2], (x+w)/64.0, (y+h)/64.0);
+	Vector2Set(texCoord[3], x/64.0, (y+h)/64.0);
+*/
+	Vector2Set(texCoord[0], (float)x/(float)image->width, (float)y/(float)image->height);
+	Vector2Set(texCoord[1], (float)(x+w)/(float)image->width, (float)y/(float)image->height);
+	Vector2Set(texCoord[2], (float)(x+w)/(float)image->width, (float)(y+h)/(float)image->height);
+	Vector2Set(texCoord[3], (float)x/(float)image->width, (float)(y+h)/(float)image->height);
+
+	Vector2Set(verts[0], x, y);
+	Vector2Set(verts[1], x+w, y);
+	Vector2Set(verts[2], x+w, y+h);
+	Vector2Set(verts[3], x, y+h);
+
+	rb_vertex = rb_index = 0;
+	indexArray[rb_index++] = rb_vertex+0;
+	indexArray[rb_index++] = rb_vertex+1;
+	indexArray[rb_index++] = rb_vertex+2;
+	indexArray[rb_index++] = rb_vertex+0;
+	indexArray[rb_index++] = rb_vertex+2;
+	indexArray[rb_index++] = rb_vertex+3;
+	for (i=0; i<4; i++) {
+		VA_SetElem2(texCoordArray[0][rb_vertex], texCoord[i][0], texCoord[i][1]);
+		VA_SetElem3(vertexArray[rb_vertex], verts[i][0], verts[i][1], 0);
+		VA_SetElem4(colorArray[rb_vertex], 1.0, 1.0, 1.0, 1.0);
+		rb_vertex++;
+	}
+	RB_RenderMeshGeneric (false);
+}
+
+#endif

renderer/r_local.h

@@ -622,7 +622,7 @@ extern unsigned rb_vertex, rb_index;
 
 void RB_InitBackend (void);
 float RB_CalcGlowColor (renderparms_t *parms);
-void RB_ModifyTextureCoords (float *inArray, float *inVerts, int numVerts, renderparms_t *parms);
+void RB_ModifyTextureCoords (float *inArray, float *inVerts, int numVerts, tcmodParms_t *parms);
 qboolean RB_CheckArrayOverflow (int numVerts, int numIndex);
 void RB_RenderMeshGeneric (qboolean drawTris);
 void RB_DrawArrays (void);
@@ -716,11 +716,14 @@ char	*va(char *format, ...);
 void	R_RefreshFont (fontslot_t font);
 void	R_RefreshAllFonts (void);
 void	R_DrawGetPicSize (int *w, int *h, char *name);
-void	R_DrawPic (int x, int y, char *name);
+void	R_DrawPic (drawStruct_t ds)	;
+
+//void	R_DrawPic (int x, int y, char *name);
 // added alpha for Psychospaz's transparent console
-void	R_DrawStretchPic (int x, int y, int w, int h, char *name, float alpha);
+//void	R_DrawStretchPic (int x, int y, int w, int h, char *name, float alpha);
 // Psychospaz's scaled crosshair support
-void	R_DrawScaledPic (int x, int y, float scale, float alpha, char *pic);
+//void	R_DrawScaledPic (int x, int y, float scale, float alpha, char *pic);
+
 void	R_InitChars (void);
 void	R_FlushChars (fontslot_t font);
 void	R_DrawChar (float x, float y, int num, fontslot_t font, float scale, 

renderer/r_model.c

@@ -1492,41 +1492,41 @@ void Mod_ParseModelScript (maliasskin_t *skin, char **data, char *dataStart, int
 				break;
 			}
 			if (!Q_strcasecmp(token, "translate")) {
-				if (!Mod_ParseFloat(data, &skinParms->translate_x, false)) {
+				if (!Mod_ParseFloat(data, &skinParms->tcmod.translate_x, false)) {
 					VID_Printf (PRINT_ALL, S_COLOR_YELLOW"Mod_ParseModelScript: missing parameters for 'tcmod translate' in %s.%i in %s\n", meshname, skinnum, scriptname);
 					break;
 				}
-				if (!Mod_ParseFloat(data, &skinParms->translate_y, false)) {
+				if (!Mod_ParseFloat(data, &skinParms->tcmod.translate_y, false)) {
 					VID_Printf (PRINT_ALL, S_COLOR_YELLOW"Mod_ParseModelScript: missing parameter for 'tcmod translate' in %s.%i in %s\n", meshname, skinnum, scriptname);
-					skinParms->translate_x = 0.0f;
+					skinParms->tcmod.translate_x = 0.0f;
 					break;
 				}
 			}
 			else if (!Q_strcasecmp(token, "rotate")) {
-				if (!Mod_ParseFloat(data, &skinParms->rotate, false)) {
+				if (!Mod_ParseFloat(data, &skinParms->tcmod.rotate, false)) {
 					VID_Printf (PRINT_ALL, S_COLOR_YELLOW"Mod_ParseModelScript: missing parameter for 'tcmod rotate' in %s.%i in %s\n", meshname, skinnum, scriptname);
 					break;
 				}
 			}
 			else if (!Q_strcasecmp(token, "scale")) {
-				if (!Mod_ParseFloat(data, &skinParms->scale_x, false)) {
+				if (!Mod_ParseFloat(data, &skinParms->tcmod.scale_x, false)) {
 					VID_Printf (PRINT_ALL, S_COLOR_YELLOW"Mod_ParseModelScript: missing parameters for 'tcmod scale' in %s.%i in %s\n", meshname, skinnum, scriptname);
 					break;
 				}
-				if (!Mod_ParseFloat(data, &skinParms->scale_y, false)) {
+				if (!Mod_ParseFloat(data, &skinParms->tcmod.scale_y, false)) {
 					VID_Printf (PRINT_ALL, S_COLOR_YELLOW"Mod_ParseModelScript: missing parameter for 'tcmod scale' in %s.%i in %s\n", meshname, skinnum, scriptname);
-					skinParms->scale_x = 1.0f;
+					skinParms->tcmod.scale_x = 1.0f;
 					break;
 				}
 			}
 			else if (!Q_strcasecmp(token, "stretch"))
 			{
-				if (!Mod_ParseWaveFunc(data, &skinParms->stretch.type)) {
+				if (!Mod_ParseWaveFunc(data, &skinParms->tcmod.stretch.type)) {
 					VID_Printf (PRINT_ALL, S_COLOR_YELLOW"Mod_ParseModelScript: missing or invalid waveform for 'tcmod stretch' in %s.%i in %s\n", meshname, skinnum, scriptname);
 					break;
 				}
 				for (i=0; i<4; i++)
-					if (!Mod_ParseFloat(data, &skinParms->stretch.params[i], false)) {
+					if (!Mod_ParseFloat(data, &skinParms->tcmod.stretch.params[i], false)) {
 						VID_Printf (PRINT_ALL, S_COLOR_YELLOW"Mod_ParseModelScript: missing parameters for 'tcmod stretch' in %s.%i in %s\n", meshname, skinnum, scriptname);
 						break;
 					}
@@ -1534,21 +1534,21 @@ void Mod_ParseModelScript (maliasskin_t *skin, char **data, char *dataStart, int
 			else if (!Q_strcasecmp(token, "turb"))
 			{	// first parm (base) is unused, so just read twice
 				for (i=0; i<4; i++)
-					if (!Mod_ParseFloat(data, &skinParms->turb.params[i], false)) {
+					if (!Mod_ParseFloat(data, &skinParms->tcmod.turb.params[i], false)) {
 						VID_Printf (PRINT_ALL, S_COLOR_YELLOW"Mod_ParseModelScript: missing parameters for 'tcmod turb' in %s.%i in %s\n", meshname, skinnum, scriptname);
 						break;
 					}
-				skinParms->turb.type = WAVEFORM_SIN;
+				skinParms->tcmod.turb.type = WAVEFORM_SIN;
 			}
 			else if (!Q_strcasecmp(token, "scroll"))
 			{
-				if (!Mod_ParseFloat(data, &skinParms->scroll_x, false)) {
+				if (!Mod_ParseFloat(data, &skinParms->tcmod.scroll_x, false)) {
 					VID_Printf (PRINT_ALL, S_COLOR_YELLOW"Mod_ParseModelScript: missing parameters for 'tcmod scroll' in %s.%i in %s\n", meshname, skinnum, scriptname);
 					break;
 				}
-				if (!Mod_ParseFloat(data, &skinParms->scroll_y, false)) {
+				if (!Mod_ParseFloat(data, &skinParms->tcmod.scroll_y, false)) {
 					VID_Printf (PRINT_ALL, S_COLOR_YELLOW"Mod_ParseModelScript: missing parameter for 'tcmod scroll' in %s.%i in %s\n", meshname, skinnum, scriptname);
-					skinParms->scroll_x = 0.0f;
+					skinParms->tcmod.scroll_x = 0.0f;
 					break;
 				}
 			}
@@ -1636,6 +1636,27 @@ void Mod_ParseModelScript (maliasskin_t *skin, char **data, char *dataStart, int
 	}
 }
 
+/*
+=================
+Mod_SetTCModParmsDefaults
+md3 skin protoshaders
+=================
+*/
+void Mod_SetTCModParmsDefaults (tcmodParms_t *tcmod)
+{
+	if (!tcmod)	return;
+
+	tcmod->translate_x = 0.0f;
+	tcmod->translate_y = 0.0f;
+	tcmod->rotate = 0.0f;
+	tcmod->scale_x = 1.0f;
+	tcmod->scale_y = 1.0f;
+	tcmod->stretch.type = -1;
+	tcmod->turb.type = -1;
+	tcmod->scroll_x = 0.0f;
+	tcmod->scroll_y = 0.0f;
+}
+
 /*
 =================
 Mod_SetRenderParmsDefaults
@@ -1656,15 +1677,15 @@ void Mod_SetRenderParmsDefaults (renderparms_t *parms)
 	parms->blendfunc_src = -1;
 	parms->blendfunc_dst = -1;
 	parms->glow.type = -1;
-	parms->translate_x = 0.0f;
+	parms->tcmod.translate_x = 0.0f;
-	parms->translate_y = 0.0f;
+	parms->tcmod.translate_y = 0.0f;
-	parms->rotate = 0.0f;
+	parms->tcmod.rotate = 0.0f;
-	parms->scale_x = 1.0f;
+	parms->tcmod.scale_x = 1.0f;
-	parms->scale_y = 1.0f;
+	parms->tcmod.scale_y = 1.0f;
-	parms->stretch.type = -1;
+	parms->tcmod.stretch.type = -1;
-	parms->turb.type = -1;
+	parms->tcmod.turb.type = -1;
-	parms->scroll_x = 0.0f;
+	parms->tcmod.scroll_x = 0.0f;
-	parms->scroll_y = 0.0f;
+	parms->tcmod.scroll_y = 0.0f;
 }
 
 /*

renderer/r_model.h

@@ -302,6 +302,9 @@ typedef struct model_s
 
 void	Mod_Init (void);
 void	Mod_ClearAll (void);
+void	Mod_SetTCModParmsDefaults (tcmodParms_t *tcmod);
+void	Mod_SetRenderParmsDefaults (renderparms_t *parms);
+void	Mod_LoadModelScript (model_t *mod, maliasmodel_t *aliasmod);
 model_t *Mod_ForName (char *name, qboolean crash);
 mleaf_t *Mod_PointInLeaf (float *p, model_t *model);
 byte	*Mod_ClusterPVS (int cluster, model_t *model);

renderer/r_warp.c

@@ -121,18 +121,11 @@ void SubdividePolygon (int numverts, float *verts)
 	}
 
 	// add a point in the center to help keep warp valid
-//	poly = Hunk_Alloc (sizeof(glpoly_t) + ((numverts-4)+2) * VERTEXSIZE*sizeof(float));
 	poly = Hunk_Alloc (sizeof(glpoly_t) + ((numverts-4)+2) * sizeof(mpolyvertex_t));
 	poly->next = warpface->polys;
 	warpface->polys = poly;
 	poly->numverts = numverts+2;
 
-	// alloc vertex light fields
-/*	size = poly->numverts*3*sizeof(byte);
-	poly->vertexlight = Hunk_Alloc(size);
-	poly->vertexlightbase = Hunk_Alloc(size);
-	memset(poly->vertexlight, 0, size);
-	memset(poly->vertexlightbase, 0, size); */
 	poly->vertexlightset = false;
 	
 	VectorClear (total);
@@ -141,8 +134,10 @@ void SubdividePolygon (int numverts, float *verts)
 	for (i=0; i<numverts; i++, verts+=3)
 	{
 		VectorCopy (verts, poly->verts[i+1].xyz);
-		s = DotProduct (verts, warpface->texinfo->vecs[0]);
+	//	s = DotProduct (verts, warpface->texinfo->vecs[0]);
-		t = DotProduct (verts, warpface->texinfo->vecs[1]);
+	//	t = DotProduct (verts, warpface->texinfo->vecs[1]);
+		s = DotProduct (verts, warpface->texinfo->vecs[0]) + warpface->texinfo->vecs[0][3];
+		t = DotProduct (verts, warpface->texinfo->vecs[1]) + warpface->texinfo->vecs[1][3];
 
 		total_s += s;
 		total_t += t;

ui/ui_backend.c

@@ -44,6 +44,20 @@ static	void	MenuSpinControl_DoSlide (menulist_s *s, int dir);
 #define RCOLUMN_OFFSET  MENU_FONT_SIZE*2	// was 16
 #define LCOLUMN_OFFSET -MENU_FONT_SIZE*2	// was -16
 
+vec4_t		stCoord_arrow_left = {0.0, 0.0, 0.25, 0.25};
+vec4_t		stCoord_arrow_right = {0.25, 0.0, 0.5, 0.25};
+vec4_t		stCoord_arrow_up = {0.5, 0.0, 0.75, 0.25};
+vec4_t		stCoord_arrow_down = {0.75, 0.0, 1, 0.25};
+vec4_t		stCoord_scrollKnob_h = {0.0, 0.75, 0.25, 1.0};
+vec4_t		stCoord_scrollKnob_v = {0.25, 0.75, 0.5, 1.0};
+vec4_t		stCoord_field_left = {0.0, 0.0, 0.25, 1.0};
+vec4_t		stCoord_field_center = {0.25, 0.0, 0.5, 1.0};
+vec4_t		stCoord_field_right = {0.5, 0.0, 0.75, 1.0};
+vec4_t		stCoord_slider_left = {0.0, 0.0, 0.125, 1.0};
+vec4_t		stCoord_slider_center = {0.125, 0.0, 0.375, 1.0};
+vec4_t		stCoord_slider_right = {0.375, 0.0, 0.5, 1.0};
+vec4_t		stCoord_slider_knob = {0.5, 0.0, 0.625, 1.0};
+
 extern viddef_t viddef;
 
 #define VID_WIDTH viddef.width
@@ -141,7 +155,14 @@ void MenuField_Draw (menufield_s *f)
 		offset = (int)strlen(tempbuffer);
 	}
 
-	SCR_DrawChar (f->generic.x + f->generic.parent->x + RCOLUMN_OFFSET,
+	SCR_DrawOffsetPicST (f->generic.x + f->generic.parent->x + RCOLUMN_OFFSET,
+						f->generic.y + f->generic.parent->y - 4, f->generic.textSize, f->generic.textSize*2, vec2_origin, stCoord_field_left,
+						ALIGN_CENTER, true, color_identity, UI_FIELD_PIC);
+	SCR_DrawOffsetPicST (f->generic.x + f->generic.parent->x + (1+f->visible_length)*f->generic.textSize + RCOLUMN_OFFSET,
+						f->generic.y + f->generic.parent->y - 4, f->generic.textSize, f->generic.textSize*2, vec2_origin, stCoord_field_right,
+						ALIGN_CENTER, true, color_identity, UI_FIELD_PIC);
+
+/*	SCR_DrawChar (f->generic.x + f->generic.parent->x + RCOLUMN_OFFSET,
 				f->generic.y + f->generic.parent->y - 4, f->generic.textSize, ALIGN_CENTER, 18, FONT_UI, 255,255,255,255, false, false);
 	SCR_DrawChar (f->generic.x + f->generic.parent->x + RCOLUMN_OFFSET,
 				f->generic.y + f->generic.parent->y + 4, f->generic.textSize, ALIGN_CENTER, 24, FONT_UI, 255,255,255,255, false, false);
@@ -149,18 +170,23 @@ void MenuField_Draw (menufield_s *f)
 				f->generic.y + f->generic.parent->y - 4, f->generic.textSize, ALIGN_CENTER, 20, FONT_UI, 255,255,255,255, false, false);
 	SCR_DrawChar (f->generic.x + f->generic.parent->x + (1+f->visible_length)*f->generic.textSize + RCOLUMN_OFFSET,
 				f->generic.y + f->generic.parent->y + 4, f->generic.textSize, ALIGN_CENTER, 26, FONT_UI, 255,255,255,255, false, false);
-
+*/
 	for (i = 0; i < f->visible_length; i++)
 	{
-		SCR_DrawChar (f->generic.x + f->generic.parent->x + (1+i)*f->generic.textSize + RCOLUMN_OFFSET,
+		SCR_DrawOffsetPicST (f->generic.x + f->generic.parent->x + (1+i)*f->generic.textSize + RCOLUMN_OFFSET,
+							f->generic.y + f->generic.parent->y - 4, f->generic.textSize, f->generic.textSize*2, vec2_origin, stCoord_field_center,
+							ALIGN_CENTER, true, color_identity, UI_FIELD_PIC);
+
+	/*	SCR_DrawChar (f->generic.x + f->generic.parent->x + (1+i)*f->generic.textSize + RCOLUMN_OFFSET,
 					f->generic.y + f->generic.parent->y - 4, f->generic.textSize, ALIGN_CENTER, 19, FONT_UI, 255,255,255,255, false, false);
 		SCR_DrawChar (f->generic.x + f->generic.parent->x + (1+i)*f->generic.textSize + RCOLUMN_OFFSET,
 					f->generic.y + f->generic.parent->y + 4, f->generic.textSize, ALIGN_CENTER, 25, FONT_UI, 255,255,255,255, false, (i==(f->visible_length-1)));
+	*/
 	}
 
 	// add cursor thingie
 	if ( (Menu_ItemAtCursor(f->generic.parent) == f)  && ((int)(Sys_Milliseconds()/250))&1 )
-		Com_sprintf(tempbuffer, sizeof(tempbuffer),	"%s%c", tempbuffer, 11);
+		Com_sprintf (tempbuffer, sizeof(tempbuffer),	"%s%c", tempbuffer, 11);
 
 	Menu_DrawString (f->generic.x + f->generic.parent->x + f->generic.textSize*3,
 					f->generic.y + f->generic.parent->y, f->generic.textSize, tempbuffer, alpha);
@@ -322,9 +348,9 @@ void MenuList_Draw (menulist_s *l)
 	n = l->itemnames;
 
 //	SCR_DrawFill (l->generic.parent->x + l->generic.x - 112, l->generic.parent->y + l->generic.y + (l->curvalue+1)*MENU_LINE_SIZE,
-//				128, MENU_LINE_SIZE, ALIGN_CENTER, 16);
+//				128, MENU_LINE_SIZE, ALIGN_CENTER, false, 16);
 	SCR_DrawFill (l->generic.parent->x + l->generic.x - 112, l->generic.parent->y + l->generic.y + (l->curvalue+1)*MENU_LINE_SIZE,
-				128, MENU_LINE_SIZE, ALIGN_CENTER, color8red(16), color8green(16), color8blue(16), 255);
+				128, MENU_LINE_SIZE, ALIGN_CENTER, false, color8red(16), color8green(16), color8blue(16), 255);
 
 	while (*n)
 	{
@@ -382,7 +408,7 @@ void MenuSlider_DoSlide (menuslider_s *s, int dir)
 
 void MenuSlider_Draw (menuslider_s *s)
 {
-	int		i, alpha = mouseOverAlpha(&s->generic);
+	int		i, x, y, alpha = mouseOverAlpha(&s->generic);
 	float	tmpValue;
 	char	valueText[8];
 
@@ -402,18 +428,35 @@ void MenuSlider_Draw (menuslider_s *s)
 	if (s->range > 1)
 		s->range = 1;
 
-	SCR_DrawChar (s->generic.x + s->generic.parent->x + RCOLUMN_OFFSET,
+	x = s->generic.x + s->generic.parent->x + RCOLUMN_OFFSET;
-				s->generic.y + s->generic.parent->y, s->generic.textSize, ALIGN_CENTER, 128, FONT_UI, 255,255,255,255, false, false);
+	y = s->generic.y + s->generic.parent->y;
 
-	for (i = 0; i < SLIDER_RANGE; i++)
+	// draw left
-		SCR_DrawChar (s->generic.x + s->generic.parent->x + (i+1)*s->generic.textSize + RCOLUMN_OFFSET,
+	SCR_DrawOffsetPicST (x, y, SLIDER_ENDCAP_WIDTH, SLIDER_HEIGHT,
-					s->generic.y + s->generic.parent->y, s->generic.textSize, ALIGN_CENTER, 129, FONT_UI, 255,255,255,255, false, false);
+						vec2_origin, stCoord_slider_left, ALIGN_CENTER, true, color_identity, UI_SLIDER_PIC);
+//	SCR_DrawChar (s->generic.x + s->generic.parent->x + RCOLUMN_OFFSET,
+//				s->generic.y + s->generic.parent->y, s->generic.textSize, ALIGN_CENTER, 128, FONT_UI, 255,255,255,255, false, false);
 
-	SCR_DrawChar (s->generic.x + s->generic.parent->x + (i+1)*s->generic.textSize + RCOLUMN_OFFSET,
+	// draw center
-				s->generic.y + s->generic.parent->y, s->generic.textSize, ALIGN_CENTER, 130, FONT_UI, 255,255,255,255, false, false);
+	x += SLIDER_ENDCAP_WIDTH;
+	for (i = 0; i < SLIDER_RANGE; i++) {
+		SCR_DrawOffsetPicST (x + i*SLIDER_SECTION_WIDTH, y, SLIDER_SECTION_WIDTH, SLIDER_HEIGHT,
+							vec2_origin, stCoord_slider_center, ALIGN_CENTER, true, color_identity, UI_SLIDER_PIC);
+	//	SCR_DrawChar (s->generic.x + s->generic.parent->x + (i+1)*s->generic.textSize + RCOLUMN_OFFSET,
+	//				s->generic.y + s->generic.parent->y, s->generic.textSize, ALIGN_CENTER, 129, FONT_UI, 255,255,255,255, false, false);
+	}
 
-	SCR_DrawChar (s->generic.x + s->generic.parent->x + s->generic.textSize*((SLIDER_RANGE-1)*s->range+1) + RCOLUMN_OFFSET,
+	// draw right
-				s->generic.y + s->generic.parent->y, s->generic.textSize, ALIGN_CENTER, 131, FONT_UI, 255,255,255,255, false, true);
+	SCR_DrawOffsetPicST (x + i*SLIDER_SECTION_WIDTH, y, SLIDER_ENDCAP_WIDTH, SLIDER_HEIGHT,
+						vec2_origin, stCoord_slider_right, ALIGN_CENTER, true, color_identity, UI_SLIDER_PIC);
+//	SCR_DrawChar (s->generic.x + s->generic.parent->x + (i+1)*s->generic.textSize + RCOLUMN_OFFSET,
+//				s->generic.y + s->generic.parent->y, s->generic.textSize, ALIGN_CENTER, 130, FONT_UI, 255,255,255,255, false, false);
+
+	// draw knob
+	SCR_DrawOffsetPicST (x + SLIDER_RANGE*SLIDER_SECTION_WIDTH*s->range - (SLIDER_KNOB_WIDTH/2), y, SLIDER_KNOB_WIDTH, SLIDER_HEIGHT,
+						vec2_origin, stCoord_slider_knob, ALIGN_CENTER, true, color_identity, UI_SLIDER_PIC);
+//	SCR_DrawChar (s->generic.x + s->generic.parent->x + s->generic.textSize*((SLIDER_RANGE-1)*s->range+1) + RCOLUMN_OFFSET,
+//				s->generic.y + s->generic.parent->y, s->generic.textSize, ALIGN_CENTER, 131, FONT_UI, 255,255,255,255, false, true);
 
 	// draw value
 	tmpValue = s->curPos * s->increment + s->baseValue;
@@ -427,8 +470,10 @@ void MenuSlider_Draw (menuslider_s *s)
 		else
 			Com_sprintf (valueText, sizeof(valueText), "%4.2f", tmpValue);
 	}
-	Menu_DrawString (s->generic.x + s->generic.parent->x + s->generic.textSize*SLIDER_RANGE + RCOLUMN_OFFSET + 2.5*MENU_FONT_SIZE,
+	Menu_DrawString (s->generic.x + s->generic.parent->x + RCOLUMN_OFFSET + 2*SLIDER_ENDCAP_WIDTH + i*SLIDER_SECTION_WIDTH + MENU_FONT_SIZE/2,
 					s->generic.y + s->generic.parent->y + 1, MENU_FONT_SIZE-2, valueText, alpha);
+//	Menu_DrawString (s->generic.x + s->generic.parent->x + s->generic.textSize*SLIDER_RANGE + RCOLUMN_OFFSET + 2.5*MENU_FONT_SIZE,
+//					s->generic.y + s->generic.parent->y + 1, MENU_FONT_SIZE-2, valueText, alpha);
 }
 
 void MenuSpinControl_DoEnter (menulist_s *s)
@@ -826,20 +871,30 @@ void Menu_Draw (menuframework_s *menu)
 	}
 	else if (item && item->type != MTYPE_FIELD)
 	{
+		char	*cursor;
+		int		cursorX;
+
+		cursor = ((int)(Sys_Milliseconds()/250)&1) ? UI_ITEMCURSOR_DEFAULT_PIC : UI_ITEMCURSOR_BLINK_PIC;
+
 		if (item->flags & QMF_LEFT_JUSTIFY)
+			cursorX = menu->x + item->x + item->cursor_offset - 24;
+		else
+			cursorX = menu->x + item->cursor_offset;
+
+		SCR_DrawPic (cursorX, menu->y+item->y, item->textSize, item->textSize, ALIGN_CENTER, false, cursor, 255);
+
+	/*	if (item->flags & QMF_LEFT_JUSTIFY)
 		{
 			SCR_DrawChar (menu->x+item->x+item->cursor_offset-24, menu->y+item->y,
-			//			MENU_FONT_SIZE, ALIGN_CENTER, 12+((int)(Sys_Milliseconds()/250)&1),
 						item->textSize, ALIGN_CENTER, 12+((int)(Sys_Milliseconds()/250)&1),
 						FONT_UI, 255,255,255,255, false, true);
 		}
 		else
 		{
 			SCR_DrawChar (menu->x+item->cursor_offset, menu->y+item->y,
-			//			MENU_FONT_SIZE, ALIGN_CENTER, 12+((int)(Sys_Milliseconds()/250)&1),
 						item->textSize, ALIGN_CENTER, 12+((int)(Sys_Milliseconds()/250)&1),
 						FONT_UI, 255,255,255,255, false, true);
-		}
+		} */
 	}
 
 	if (item)
@@ -861,12 +916,12 @@ void Menu_DrawStatusBar (const char *string)
 	{
 		int l = (int)strlen( string );
 
-		SCR_DrawFill (0, SCREEN_HEIGHT-(MENU_FONT_SIZE+3), SCREEN_WIDTH, MENU_FONT_SIZE+4, ALIGN_BOTTOM_STRETCH, 60,60,60,255 );	// go 1 pixel past screen bottom to prevent gap from scaling
+		SCR_DrawFill (0, SCREEN_HEIGHT-(MENU_FONT_SIZE+3), SCREEN_WIDTH, MENU_FONT_SIZE+4, ALIGN_BOTTOM_STRETCH, false, 60,60,60,255 );	// go 1 pixel past screen bottom to prevent gap from scaling
-		SCR_DrawFill (0, SCREEN_HEIGHT-(MENU_FONT_SIZE+3), SCREEN_WIDTH, 1, ALIGN_BOTTOM_STRETCH, 0,0,0,255 );
+		SCR_DrawFill (0, SCREEN_HEIGHT-(MENU_FONT_SIZE+3), SCREEN_WIDTH, 1, ALIGN_BOTTOM_STRETCH, false, 0,0,0,255 );
 		SCR_DrawString (SCREEN_WIDTH/2-(l/2)*MENU_FONT_SIZE, SCREEN_HEIGHT-(MENU_FONT_SIZE+1), MENU_FONT_SIZE, ALIGN_BOTTOM, string, FONT_UI, 255 );
 	}
 	else
-		SCR_DrawFill (0, SCREEN_HEIGHT-(MENU_FONT_SIZE+3), SCREEN_WIDTH, MENU_FONT_SIZE+4, ALIGN_BOTTOM_STRETCH, 0,0,0,255 );	// go 1 pixel past screen bottom to prevent gap from scaling
+		SCR_DrawFill (0, SCREEN_HEIGHT-(MENU_FONT_SIZE+3), SCREEN_WIDTH, MENU_FONT_SIZE+4, ALIGN_BOTTOM_STRETCH, false, 0,0,0,255 );	// go 1 pixel past screen bottom to prevent gap from scaling
 }
 
 void Menu_DrawString (int x, int y, int size, const char *string, int alpha)
@@ -907,15 +962,29 @@ void Menu_DrawTextBox (int x, int y, int width, int lines)
 {
 	int		cx, cy;
 	int		n;
+/*	vec4_t	stCoord_textBox[9];
 
+	Vector4Set (stCoord_textBox[0], 0.0, 0.0, 0.25, 0.25);
+	Vector4Set (stCoord_textBox[1], 0.0, 0.25, 0.25, 0.5);
+	Vector4Set (stCoord_textBox[2], 0.0, 0.5, 0.25, 0.75);
+	Vector4Set (stCoord_textBox[3], 0.25, 0.0, 0.5, 0.25);
+	Vector4Set (stCoord_textBox[4], 0.25, 0.25, 0.5, 0.5);
+	Vector4Set (stCoord_textBox[5], 0.25, 0.5, 0.5, 0.75);
+	Vector4Set (stCoord_textBox[6], 0.5, 0.0, 0.75, 0.25);
+	Vector4Set (stCoord_textBox[7], 0.5, 0.25, 0.75, 0.5);
+	Vector4Set (stCoord_textBox[8], 0.5, 0.5, 0.75, 0.75);
+*/
 	// draw left side
 	cx = x;
 	cy = y;
+//	SCR_DrawOffsetPicST (cx, cy, MENU_FONT_SIZE, MENU_FONT_SIZE, vec2_origin, stCoord_textBox[0], ALIGN_CENTER, true, color_identity, UI_TEXTBOX_PIC);
 	SCR_DrawChar (cx, cy, MENU_FONT_SIZE, ALIGN_CENTER, 1, FONT_UI, 255,255,255,255, false, false);
 	for (n = 0; n < lines; n++) {
 		cy += MENU_FONT_SIZE;
+	//	SCR_DrawOffsetPicST (cx, cy, MENU_FONT_SIZE, MENU_FONT_SIZE, vec2_origin, stCoord_textBox[1], ALIGN_CENTER, true, color_identity, UI_TEXTBOX_PIC);
 		SCR_DrawChar (cx, cy, MENU_FONT_SIZE, ALIGN_CENTER, 4, FONT_UI, 255,255,255,255, false, false);
 	}
+//	SCR_DrawOffsetPicST (cx, cy, MENU_FONT_SIZE, MENU_FONT_SIZE, vec2_origin, stCoord_textBox[2], ALIGN_CENTER, true, color_identity, UI_TEXTBOX_PIC);
 	SCR_DrawChar (cx, cy+MENU_FONT_SIZE, MENU_FONT_SIZE, ALIGN_CENTER, 7, FONT_UI, 255,255,255,255, false, false);
 
 	// draw middle
@@ -923,11 +992,14 @@ void Menu_DrawTextBox (int x, int y, int width, int lines)
 	while (width > 0)
 	{
 		cy = y;
+	//	SCR_DrawOffsetPicST (cx, cy, MENU_FONT_SIZE, MENU_FONT_SIZE, vec2_origin, stCoord_textBox[3], ALIGN_CENTER, true, color_identity, UI_TEXTBOX_PIC);
 		SCR_DrawChar (cx, cy, MENU_FONT_SIZE, ALIGN_CENTER, 2, FONT_UI, 255,255,255,255, false, false);
 		for (n = 0; n < lines; n++) {
 			cy += MENU_FONT_SIZE;
+		//	SCR_DrawOffsetPicST (cx, cy, MENU_FONT_SIZE, MENU_FONT_SIZE, vec2_origin, stCoord_textBox[4], ALIGN_CENTER, true, color_identity, UI_TEXTBOX_PIC);
 			SCR_DrawChar (cx, cy, MENU_FONT_SIZE, ALIGN_CENTER, 5, FONT_UI, 255,255,255,255, false, false);
 		}
+	//	SCR_DrawOffsetPicST (cx, cy, MENU_FONT_SIZE, MENU_FONT_SIZE, vec2_origin, stCoord_textBox[5], ALIGN_CENTER, true, color_identity, UI_TEXTBOX_PIC);
 		SCR_DrawChar (cx, cy+MENU_FONT_SIZE, MENU_FONT_SIZE, ALIGN_CENTER, 8, FONT_UI, 255,255,255,255, false, false);
 		width -= 1;
 		cx += MENU_FONT_SIZE;
@@ -935,11 +1007,14 @@ void Menu_DrawTextBox (int x, int y, int width, int lines)
 
 	// draw right side
 	cy = y;
+//	SCR_DrawOffsetPicST (cx, cy, MENU_FONT_SIZE, MENU_FONT_SIZE, vec2_origin, stCoord_textBox[6], ALIGN_CENTER, true, color_identity, UI_TEXTBOX_PIC);
 	SCR_DrawChar (cx, cy, MENU_FONT_SIZE, ALIGN_CENTER, 3, FONT_UI, 255,255,255,255, false, false);
 	for (n = 0; n < lines; n++) {
 		cy += MENU_FONT_SIZE;
+	//	SCR_DrawOffsetPicST (cx, cy, MENU_FONT_SIZE, MENU_FONT_SIZE, vec2_origin, stCoord_textBox[7], ALIGN_CENTER, true, color_identity, UI_TEXTBOX_PIC);
 		SCR_DrawChar (cx, cy, MENU_FONT_SIZE, ALIGN_CENTER, 6, FONT_UI, 255,255,255,255, false, false);
 	}
+//	SCR_DrawOffsetPicST (cx, cy, MENU_FONT_SIZE, MENU_FONT_SIZE, vec2_origin, stCoord_textBox[8], ALIGN_CENTER, true, color_identity, UI_TEXTBOX_PIC);
 	SCR_DrawChar (cx, cy+MENU_FONT_SIZE, MENU_FONT_SIZE, ALIGN_CENTER, 9, FONT_UI, 255,255,255,255, false, true);
 }
 
@@ -954,7 +1029,7 @@ void Menu_DrawBanner (char *name)
 	int w, h;
 
 	R_DrawGetPicSize (&w, &h, name );
-	SCR_DrawPic (SCREEN_WIDTH/2-w/2, SCREEN_HEIGHT/2-150, w, h, ALIGN_CENTER, name, 1.0);
+	SCR_DrawPic (SCREEN_WIDTH/2-w/2, SCREEN_HEIGHT/2-150, w, h, ALIGN_CENTER, false, name, 1.0);
 }
 
 
@@ -1087,7 +1162,7 @@ void UI_RefreshCursorLink (void)
 	ui_mousecursor.menuitem = NULL;
 }
 
-#if 0
+#if 1
 /*
 =================
 Slider_CursorPositionX
@@ -1097,14 +1172,19 @@ int Slider_CursorPositionX (menuslider_s *s)
 {
 	float range;
 
-	range = (s->curvalue - s->minvalue) / (float)(s->maxvalue - s->minvalue);
+	if (!s)
+		return 0;
+
+//	range = (s->curvalue - s->minvalue) / (float)(s->maxvalue - s->minvalue);
+	range = (float)s->curPos / (float)s->maxPos;
 
 	if (range < 0)
 		range = 0;
 	if (range > 1)
 		range = 1;
 
-	return (int)(SCR_ScaledScreen(MENU_FONT_SIZE) + RCOLUMN_OFFSET + (SLIDER_RANGE)*SCR_ScaledScreen(MENU_FONT_SIZE) * range);
+//	return (int)(s->generic.x + s->generic.parent->x + RCOLUMN_OFFSET + MENU_FONT_SIZE + SLIDER_RANGE*MENU_FONT_SIZE*range);
+	return (int)(s->generic.x + s->generic.parent->x + RCOLUMN_OFFSET + SLIDER_ENDCAP_WIDTH + SLIDER_RANGE*SLIDER_SECTION_WIDTH*range);
 }
 
 /*
@@ -1112,19 +1192,26 @@ int Slider_CursorPositionX (menuslider_s *s)
 NewSliderValueForX
 =================
 */
-int NewSliderValueForX (int x, menuslider_s *s)
+int NewSliderValueForX (menuslider_s *s, int x)
 {
 	float	newValue, sliderbase;
 	int		newValueInt;
 	int		pos;
-	
+
-	sliderbase = s->generic.x + s->generic.parent->x + MENU_FONT_SIZE + RCOLUMN_OFFSET;
+	if (!s)
+		return 0;
+
+//	sliderbase = s->generic.x + s->generic.parent->x + MENU_FONT_SIZE + RCOLUMN_OFFSET;
+	sliderbase = s->generic.x + s->generic.parent->x + RCOLUMN_OFFSET + SLIDER_ENDCAP_WIDTH;
 	SCR_ScaleCoords (&sliderbase, NULL, NULL, NULL, ALIGN_CENTER);
 	pos = x - sliderbase;
 //	pos = x - SCR_ScaledScreen(s->generic.x + s->generic.parent->x + MENU_FONT_SIZE + RCOLUMN_OFFSET);
 
-	newValue = ((float)pos)/((SLIDER_RANGE-1)*SCR_ScaledScreen(MENU_FONT_SIZE));
+//	newValue = ((float)pos) / ((SLIDER_RANGE-1) * SCR_ScaledScreen(MENU_FONT_SIZE));
-	newValueInt = s->minvalue + newValue * (float)(s->maxvalue - s->minvalue);
+//	newValueInt = s->minvalue + newValue * (float)(s->maxvalue - s->minvalue);
+	newValue = ((float)pos) / (SCR_ScaledScreen(SLIDER_RANGE*SLIDER_SECTION_WIDTH));
+	newValue = min(newValue, 1.0f);
+	newValueInt = newValue * (float)(s->maxPos);
 
 	return newValueInt;
 }
@@ -1136,10 +1223,14 @@ Slider_CheckSlide
 */
 void Slider_CheckSlide (menuslider_s *s)
 {
-	if (s->curvalue > s->maxvalue)
+	if (!s)
-		s->curvalue = s->maxvalue;
+		return;
-	else if (s->curvalue < s->minvalue)
+
-		s->curvalue = s->minvalue;
+//	if (s->curvalue > s->maxvalue)
+//		s->curvalue = s->maxvalue;
+//	else if (s->curvalue < s->minvalue)
+//		s->curvalue = s->minvalue;
+	s->curPos = min(max(s->curPos, 0), s->maxPos);
 
 	if (s->generic.callback)
 		s->generic.callback (s);
@@ -1152,11 +1243,16 @@ Menu_DragSlideItem
 */
 void Menu_DragSlideItem (menuframework_s *menu, void *menuitem)
 {
-//	menucommon_s *item = (menucommon_s *) menuitem;
+	menuslider_s *slider;
-	menuslider_s *slider = (menuslider_s *) menuitem;
 
-	slider->curvalue = NewSliderValueForX(cursor.x, slider);
+	if (!menu || !menuitem)
-	Slider_CheckSlide( slider );
+		return;
+
+	slider = (menuslider_s *) menuitem;
+
+//	slider->curvalue = NewSliderValueForX(slider, ui_mousecursor.x);
+	slider->curPos = NewSliderValueForX(slider, ui_mousecursor.x);
+	Slider_CheckSlide (slider);
 }
 
 /*
@@ -1168,18 +1264,58 @@ void Menu_ClickSlideItem (menuframework_s *menu, void *menuitem)
 {
 	int				min, max;
 	float			x, w;
-	menucommon_s	*item = (menucommon_s *) menuitem;
+	menuslider_s	*slider;
-	menuslider_s	*slider = (menuslider_s *) menuitem;
+	
+	if (!menu || !menuitem)
+		return;
 
-	x = menu->x + item->x + Slider_CursorPositionX(slider) - 4;
+	slider = (menuslider_s *)menuitem;
-	w = 8;
+
+//	x = menu->x + item->x + Slider_CursorPositionX(slider) - 4;
+//	w = 8;
+	x = Slider_CursorPositionX(slider) - (SLIDER_KNOB_WIDTH/2);
+	w = SLIDER_KNOB_WIDTH;
 	SCR_ScaleCoords (&x, NULL, &w, NULL, ALIGN_CENTER);
 	min = x;	max = x + w;
 
-	if (cursor.x < min)
+	if (ui_mousecursor.x < min)
-		Menu_SlideItem( menu, -1 );
+		Menu_SlideItem (menu, -1);
-	if (cursor.x > max)
+	if (ui_mousecursor.x > max)
-		Menu_SlideItem( menu, 1 );
+		Menu_SlideItem (menu, 1);
+}
+
+/*
+=================
+Menu_CheckSlider_Mouseover
+=================
+*/
+qboolean Menu_CheckSlider_Mouseover (menuframework_s *menu, void *menuitem)
+{
+	int				min[2], max[2];
+	float			x1, y1, x2, y2;
+	menuslider_s	*s;
+
+	if (!menu || !menuitem)
+		return false;
+
+	s = (menuslider_s *)menuitem;
+
+	x1 = s->generic.x + s->generic.parent->x + RCOLUMN_OFFSET + SLIDER_ENDCAP_WIDTH;
+	y1 = s->generic.y + s->generic.parent->y;
+	x2 = x1 + SLIDER_RANGE*SLIDER_SECTION_WIDTH + SLIDER_ENDCAP_WIDTH;
+	y2 = y1 + SLIDER_HEIGHT;
+
+	SCR_ScaleCoords (&x1, &y1, NULL, NULL, ALIGN_CENTER);
+	SCR_ScaleCoords (&x2, &y2, NULL, NULL, ALIGN_CENTER);
+	min[0] = x1;	max[0] = x2;
+	min[1] = y1;	max[1] = y2;
+
+	if ( ui_mousecursor.x >= min[0] && ui_mousecursor.x <= max[0] 
+		&& ui_mousecursor.y >= min[1] &&  ui_mousecursor.y <= max[1] )
+		return true;
+	else
+		return false;
+
 }
 #endif
 
@@ -1195,7 +1331,7 @@ void UI_Think_MouseCursor (void)
 
 	if (m_drawfunc == M_Main_Draw) // have to hack for main menu :p
 	{
-		UI_CheckMainMenuMouse();
+		UI_CheckMainMenuMouse ();
 		return;
 	}
 	if (m_drawfunc == M_Credits_MenuDraw) // have to hack for credits :p
@@ -1206,7 +1342,7 @@ void UI_Think_MouseCursor (void)
 			ui_mousecursor.buttonclicks[MOUSEBUTTON2] = 0;
 			ui_mousecursor.buttonused[MOUSEBUTTON1] = true;
 			ui_mousecursor.buttonclicks[MOUSEBUTTON1] = 0;
-			S_StartLocalSound( menu_out_sound );
+			S_StartLocalSound (menu_out_sound);
 			if (creditsBuffer)
 				FS_FreeFile (creditsBuffer);
 			UI_PopMenu();
@@ -1233,16 +1369,20 @@ void UI_Think_MouseCursor (void)
 		{
 			if (ui_mousecursor.menuitemtype == MENUITEM_SLIDER && !ui_mousecursor.buttonused[MOUSEBUTTON1])
 			{
-			//	Menu_DragSlideItem(m, ui_mousecursor.menuitem);
+				if ( Menu_CheckSlider_Mouseover(m, ui_mousecursor.menuitem) ) {
-				Menu_SlideItem (m, 1);
+					Menu_DragSlideItem (m, ui_mousecursor.menuitem);
-				sound = menu_move_sound;
+					sound = menu_drag_sound;
-				ui_mousecursor.buttonused[MOUSEBUTTON1] = true;
+				}
+				else {
+					Menu_SlideItem (m, 1);
+					sound = menu_move_sound;
+					ui_mousecursor.buttonused[MOUSEBUTTON1] = true;
+				}
 			}
 			else if (!ui_mousecursor.buttonused[MOUSEBUTTON1] && ui_mousecursor.buttonclicks[MOUSEBUTTON1])
 			{
 				if (ui_mousecursor.menuitemtype == MENUITEM_ROTATE)
 				{
-				//	if (ui_item_rotate->value)					
 					if (ui_item_rotate->integer)					
 						Menu_SlideItem (m, -1);
 					else			
@@ -1264,8 +1404,12 @@ void UI_Think_MouseCursor (void)
 		{
 			if (ui_mousecursor.menuitemtype == MENUITEM_SLIDER && !ui_mousecursor.buttonused[MOUSEBUTTON2])
 			{
-			//	Menu_ClickSlideItem(m, ui_mousecursor.menuitem);
+				if ( Menu_CheckSlider_Mouseover(m, ui_mousecursor.menuitem) ) {
-				Menu_SlideItem (m, -1);
+					Menu_ClickSlideItem (m, ui_mousecursor.menuitem);
+				}
+				else {
+					Menu_SlideItem (m, -1);
+				}
 				sound = menu_move_sound;
 				ui_mousecursor.buttonused[MOUSEBUTTON2] = true;
 			}
@@ -1273,7 +1417,6 @@ void UI_Think_MouseCursor (void)
 			{
 				if (ui_mousecursor.menuitemtype == MENUITEM_ROTATE)
 				{
-				//	if (ui_item_rotate->value)					
 					if (ui_item_rotate->integer)					
 						Menu_SlideItem (m, 1);
 					else			
@@ -1321,17 +1464,19 @@ UI_Draw_Cursor
 #if 1
 void UI_Draw_Cursor (void)
 {
-	int		w, h;
+//	int		w, h;
-	float	ofs_x, ofs_y;
+//	float	ofs_x, ofs_y;
 	float	scale = SCR_ScaledScreen(ui_cursor_scale->value); // 0.4
 	char	*cur_img = UI_MOUSECURSOR_PIC;
 
-	//get sizing vars
+	// get sizing vars
-	R_DrawGetPicSize( &w, &h, UI_MOUSECURSOR_PIC );
+/*	R_DrawGetPicSize (&w, &h, UI_MOUSECURSOR_PIC);
 	ofs_x = SCR_ScaledScreen(w) * ui_cursor_scale->value * 0.5;
 	ofs_y = SCR_ScaledScreen(h) * ui_cursor_scale->value * 0.5;
 	
 	R_DrawScaledPic (ui_mousecursor.x - ofs_x, ui_mousecursor.y - ofs_y, scale, 1.0f, cur_img);
+*/
+	SCR_DrawScaledPic (ui_mousecursor.x, ui_mousecursor.y, scale, true, false, cur_img, 1.0f);
 }
 #else
 void UI_Draw_Cursor (void)

ui/ui_game_saveload.c

@@ -67,12 +67,12 @@ void Menu_DrawSaveshot (qboolean loadmenu)
 	}
 	shotname = UI_UpdateSaveshot (i);
 
-	SCR_DrawFill (SCREEN_WIDTH/2+44, SCREEN_HEIGHT/2-70, 244, 184, ALIGN_CENTER, 60,60,60,255);
+	SCR_DrawFill (SCREEN_WIDTH/2+44, SCREEN_HEIGHT/2-70, 244, 184, ALIGN_CENTER, false, 60,60,60,255);
 
 	if (shotname)
-		SCR_DrawPic (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, shotname, 1.0);
+		SCR_DrawPic (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, false, shotname, 1.0);
 	else
-		SCR_DrawFill (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, 0,0,0,255);
+		SCR_DrawFill (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, false, 0,0,0,255);
 }
 #else
 void Menu_DrawSaveshot (qboolean loadmenu)
@@ -94,25 +94,25 @@ void Menu_DrawSaveshot (qboolean loadmenu)
 			i = s_savegame_actions[s_savegame_menu.cursor].generic.localdata[0];
 	}
 
-	SCR_DrawFill (SCREEN_WIDTH/2+44, SCREEN_HEIGHT/2-70, 244, 184, ALIGN_CENTER, 60,60,60,255);
+	SCR_DrawFill (SCREEN_WIDTH/2+44, SCREEN_HEIGHT/2-70, 244, 184, ALIGN_CENTER, false, 60,60,60,255);
 
 	if ( loadmenu && (i == 0) && ui_savevalid[i] && ui_saveshotvalid[i])	// m_mapshotvalid ) // autosave shows mapshot
 	{
 		Com_sprintf(mapshotname, sizeof(mapshotname), "/levelshots/%s.pcx", ui_mapname);
 
-		SCR_DrawPic (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, mapshotname, 1.0);
+		SCR_DrawPic (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, false, mapshotname, 1.0);
 	}
 	else if ( ui_savevalid[i] && ui_saveshotvalid[i] )
 	{
 	//	Com_sprintf(shotname, sizeof(shotname), "/save/kmq2save%03i/shot.jpg", i);
 		Com_sprintf(shotname, sizeof(shotname), "/"SAVEDIRNAME"/kmq2save%03i/shot.jpg", i);
 
-		SCR_DrawPic (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, shotname, 1.0);
+		SCR_DrawPic (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, false, shotname, 1.0);
 	}
 	else if (ui_saveshotvalid[UI_MAX_SAVEGAMES])
-		SCR_DrawPic (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, "/gfx/ui/noscreen.pcx", 1.0);
+		SCR_DrawPic (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, false, "/gfx/ui/noscreen.pcx", 1.0);
 	else
-		SCR_DrawFill (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, 0,0,0,255);
+		SCR_DrawFill (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, false, 0,0,0,255);
 }
 #endif
 

ui/ui_local.h

@@ -59,6 +59,11 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #define LCOLUMN_OFFSET -MENU_FONT_SIZE*2	// was -16
 
 #define SLIDER_RANGE 10
+#define SLIDER_HEIGHT 8
+#define SLIDER_ENDCAP_WIDTH 5 // was 8
+#define SLIDER_SECTION_WIDTH 10 // was 8
+#define SLIDER_KNOB_WIDTH 5 // was 8
+#define SLIDER_V_OFFSET (SLIDER_HEIGHT-MENU_FONT_SIZE)/2
 //
 
 
@@ -190,7 +195,14 @@ typedef struct
 
 cursor_t ui_mousecursor;
 
+//
 // ui_backend.c
+//
+extern	vec4_t stCoord_arrow_left;
+extern	vec4_t stCoord_arrow_right;
+extern	vec4_t stCoord_arrow_up;
+extern	vec4_t stCoord_arrow_down;
+
 qboolean MenuField_Key (menufield_s *field, int key);
 void	MenuSlider_SetValue (menuslider_s *s, float value);
 float	MenuSlider_GetValue (menuslider_s *s);
@@ -392,15 +404,28 @@ void UI_Shutdown (void);
 #define UI_MOUSECURSOR_TEXT_PIC		"/gfx/ui/cursors/m_cur_text.pcx"
 
 #define UI_MOUSECURSOR_PIC			"/gfx/ui/cursors/m_mouse_cursor.pcx"
+#define UI_ITEMCURSOR_DEFAULT_PIC	"/gfx/ui/cursors/cursor_menuitem_default.pcx"
+#define UI_ITEMCURSOR_KEYBIND_PIC	"/gfx/ui/cursors/cursor_menuitem_keybind.pcx"
+#define UI_ITEMCURSOR_BLINK_PIC		"/gfx/ui/cursors/cursor_menuitem_blink.pcx"
+
+#define UI_CHECKBOX_ON_PIC			"/gfx/ui/widgets/checkbox_on.pcx"
+#define UI_CHECKBOX_OFF_PIC			"/gfx/ui/widgets/checkbox_off.pcx"
+#define UI_FIELD_PIC				"/gfx/ui/widgets/field.pcx"
+#define UI_TEXTBOX_PIC				"/gfx/ui/widgets/textbox.pcx"
+#define UI_SLIDER_PIC				"/gfx/ui/widgets/slider.pcx"
+#define UI_ARROWS_PIC				"/gfx/ui/widgets/arrows.pcx"
 
 extern	cvar_t	*ui_sensitivity;
 extern	cvar_t	*ui_background_alpha;
 extern	cvar_t	*ui_item_rotate;
 extern	cvar_t	*ui_cursor_scale;
 
-static char *menu_in_sound		= "misc/menu1.wav";
+// moved these declarations to ui_subsystem.c to avoid redundancy
-static char *menu_move_sound	= "misc/menu2.wav";
+extern	char *menu_null_sound;
-static char *menu_out_sound		= "misc/menu3.wav";
+extern	char *menu_in_sound;
+extern	char *menu_move_sound;
+extern	char *menu_out_sound;
+extern	char *menu_drag_sound;
 
 extern qboolean	ui_entersound;		// play after drawing a frame, so caching
 									// won't disrupt the sound

ui/ui_main.c

@@ -110,7 +110,7 @@ void UI_DrawMainCursor (int x, int y, int f)
 
 	Com_sprintf (cursorname, sizeof(cursorname), "m_cursor%d", f);
 	R_DrawGetPicSize (&w, &h, cursorname);
-	SCR_DrawPic (x, y, w, h, ALIGN_CENTER, cursorname, 1.0);
+	SCR_DrawPic (x, y, w, h, ALIGN_CENTER, false, cursorname, 1.0);
 }
 
 
@@ -200,7 +200,7 @@ void M_Main_Draw (void)
 	for (i = 0; main_names[i] != 0; i++)
 		if (i != m_main_cursor) {
 			R_DrawGetPicSize (&w, &h, main_names[i]);
-			SCR_DrawPic (xoffset, (ystart + i*40+3), w, h, ALIGN_CENTER, main_names[i], 1.0);
+			SCR_DrawPic (xoffset, (ystart + i*40+3), w, h, ALIGN_CENTER, false, main_names[i], 1.0);
 		}
 
 //	strncpy (litname, main_names[m_main_cursor]);
@@ -208,7 +208,7 @@ void M_Main_Draw (void)
 	Q_strncpyz (litname, sizeof(litname), main_names[m_main_cursor]);
 	Q_strncatz (litname, sizeof(litname), "_sel");
 	R_DrawGetPicSize (&w, &h, litname);
-	SCR_DrawPic (xoffset-1, (ystart + m_main_cursor*40+2), w+2, h+2, ALIGN_CENTER, litname, 1.0);
+	SCR_DrawPic (xoffset-1, (ystart + m_main_cursor*40+2), w+2, h+2, ALIGN_CENTER, false, litname, 1.0);
 
 	// Draw our nifty quad damage model as a cursor if it's loaded.
 	if (quadModel_loaded)
@@ -217,11 +217,11 @@ void M_Main_Draw (void)
 		UI_DrawMainCursor (xoffset-25, ystart+(m_main_cursor*40+1), (int)(cls.realtime/100)%NUM_MAINMENU_CURSOR_FRAMES);
 
 	R_DrawGetPicSize (&w, &h, "m_main_plaque");
-	SCR_DrawPic (xoffset-(w/2+50), ystart, w, h, ALIGN_CENTER, "m_main_plaque", 1.0);
+	SCR_DrawPic (xoffset-(w/2+50), ystart, w, h, ALIGN_CENTER, false, "m_main_plaque", 1.0);
 	last_h = h;
 
 	R_DrawGetPicSize (&w, &h, "m_main_logo");
-	SCR_DrawPic (xoffset-(w/2+50), ystart+last_h+20, w, h, ALIGN_CENTER, "m_main_logo", 1.0);
+	SCR_DrawPic (xoffset-(w/2+50), ystart+last_h+20, w, h, ALIGN_CENTER, false, "m_main_logo", 1.0);
 }
 
 

ui/ui_mp_playersetup.c

@@ -451,38 +451,50 @@ void PlayerConfig_MouseClick (void)
 
 void PlayerConfig_DrawSkinSelection (void)
 {
-	char	scratch[MAX_QPATH];
+	char		scratch[MAX_QPATH];
-	float	icon_x = SCREEN_WIDTH*0.5 - 5; // width - 325
+	float		icon_x = SCREEN_WIDTH*0.5 - 5; // width - 325
-	float	icon_y = SCREEN_HEIGHT - 108;
+	float		icon_y = SCREEN_HEIGHT - 108;
-	float	icon_offset = 0;
+	float		icon_offset = 0;
-	float	x, y, w, h;
+	float		x, y, w, h;
-	int		i, count, color[3];
+	int			i, count, color[3];
+	color_t		arrowColor;
+	vec4_t		arrowTemp[2];
 
 	CL_TextColor ((int)Cvar_VariableValue("alt_text_color"), &color[0], &color[1], &color[2]);
+	Vector4Copy (stCoord_arrow_left, arrowTemp[0]);
+	Vector4Copy (stCoord_arrow_right, arrowTemp[1]);
 
 	if ( (ui_pmi[s_playerconfig_model_box.curvalue].nskins < NUM_SKINBOX_ITEMS) || (s_playerconfig_skin_box.curvalue < 4) )
 		i = 0;
 	else if ( s_playerconfig_skin_box.curvalue > (ui_pmi[s_playerconfig_model_box.curvalue].nskins - 4) )
 		i = ui_pmi[s_playerconfig_model_box.curvalue].nskins-NUM_SKINBOX_ITEMS;
 	else
-		i = s_playerconfig_skin_box.curvalue-3;
+		i = s_playerconfig_skin_box.curvalue - 3;
 
 	// left arrow
-	if (i > 0)
+	if (i > 0) {
-		Com_sprintf (scratch, sizeof(scratch), "/gfx/ui/arrows/arrow_left.pcx");
+		Vector4Set (arrowColor, color[0], color[1], color[2], 255);
-	else
+	//	Com_sprintf (scratch, sizeof(scratch), "/gfx/ui/arrows/arrow_left.pcx");
-		Com_sprintf (scratch, sizeof(scratch), "/gfx/ui/arrows/arrow_left_d.pcx");
+	}
-	SCR_DrawPic (icon_x-39, icon_y+2, 32, 32,  ALIGN_CENTER, scratch, 1.0);
+	else {
+		Vector4Set (arrowColor, 150, 150, 150, 255);
+		arrowTemp[0][1] += 0.25;
+		arrowTemp[0][3] += 0.25;
+	//	Com_sprintf (scratch, sizeof(scratch), "/gfx/ui/arrows/arrow_left_d.pcx");
+	}
+	SCR_DrawOffsetPicST (icon_x-39, icon_y+2, 32, 32, vec2_origin, arrowTemp[0], ALIGN_CENTER, false, arrowColor, UI_ARROWS_PIC);
+//	SCR_DrawPic (icon_x-39, icon_y+2, 32, 32,  ALIGN_CENTER, false, scratch, 1.0);
 
 	// background
-	SCR_DrawFill (icon_x-3, icon_y-3, NUM_SKINBOX_ITEMS*34+4, 38, ALIGN_CENTER, 0,0,0,255);
+	SCR_DrawFill (icon_x-3, icon_y-3, NUM_SKINBOX_ITEMS*34+4, 38, ALIGN_CENTER, false, 0, 0, 0, 255);
-	if (R_DrawFindPic("/gfx/ui/listbox_background.pcx")) {
+	if (R_DrawFindPic("/gfx/ui/widgets/listbox_background.pcx")) {
-		x = icon_x-2;	y = icon_y-2;	w = NUM_SKINBOX_ITEMS*34+2;	h = 36;
+		x = icon_x-2;	y = icon_y-2;	w = NUM_SKINBOX_ITEMS * 34 + 2;	h = 36;
-		SCR_ScaleCoords (&x, &y, &w, &h, ALIGN_CENTER);
+		SCR_DrawTiledPic (x, y, w, h, ALIGN_CENTER, true, "/gfx/ui/widgets/listbox_background.pcx", 255);
-		R_DrawTileClear ((int)x, (int)y, (int)w, (int)h, "/gfx/ui/listbox_background.pcx");
+	//	SCR_ScaleCoords (&x, &y, &w, &h, ALIGN_CENTER);
+	//	R_DrawTileClear ((int)x, (int)y, (int)w, (int)h, "/gfx/ui/widgets/listbox_background.pcx");
 	}
 	else
-		SCR_DrawFill (icon_x-2, icon_y-2, NUM_SKINBOX_ITEMS*34+2, 36, ALIGN_CENTER, 60,60,60,255);
+		SCR_DrawFill (icon_x-2, icon_y-2, NUM_SKINBOX_ITEMS*34+2, 36, ALIGN_CENTER, false, 60, 60, 60, 255);
 		
 	for (count=0; count<NUM_SKINBOX_ITEMS; i++,count++)
 	{
@@ -494,18 +506,25 @@ void PlayerConfig_DrawSkinSelection (void)
 			ui_pmi[s_playerconfig_model_box.curvalue].skinDisplayNames[i] );
 
 		if (i == s_playerconfig_skin_box.curvalue)
-			SCR_DrawFill (icon_x + icon_offset-1, icon_y-1, 34, 34, ALIGN_CENTER, color[0],color[1],color[2],255);
+			SCR_DrawFill (icon_x + icon_offset-1, icon_y-1, 34, 34, ALIGN_CENTER, false, color[0], color[1] ,color[2], 255);
-		SCR_DrawPic (icon_x + icon_offset, icon_y, 32, 32,  ALIGN_CENTER, scratch, 1.0);
+		SCR_DrawPic (icon_x + icon_offset, icon_y, 32, 32,  ALIGN_CENTER, false, scratch, 1.0);
 		icon_offset += 34;
 	}
 
 	// right arrow
 	icon_offset = NUM_SKINBOX_ITEMS*34;
-	if (ui_pmi[s_playerconfig_model_box.curvalue].nskins-i>0)
+	if ( ui_pmi[s_playerconfig_model_box.curvalue].nskins-i > 0 ) {
-		Com_sprintf (scratch, sizeof(scratch), "/gfx/ui/arrows/arrow_right.pcx");
+		Vector4Set (arrowColor, color[0], color[1], color[2], 255);
-	else
+	//	Com_sprintf (scratch, sizeof(scratch), "/gfx/ui/arrows/arrow_right.pcx");
-		Com_sprintf (scratch, sizeof(scratch), "/gfx/ui/arrows/arrow_right_d.pcx"); 
+	}
-	SCR_DrawPic (icon_x+icon_offset+5, icon_y+2, 32, 32,  ALIGN_CENTER, scratch, 1.0);
+	else {
+		Vector4Set (arrowColor, 150, 150, 150, 255);
+		arrowTemp[1][1] += 0.25;
+		arrowTemp[1][3] += 0.25;
+	//	Com_sprintf (scratch, sizeof(scratch), "/gfx/ui/arrows/arrow_right_d.pcx");
+	}
+	SCR_DrawOffsetPicST (icon_x+icon_offset+5, icon_y+2, 32, 32, vec2_origin, arrowTemp[1], ALIGN_CENTER, false, arrowColor, UI_ARROWS_PIC);
+//	SCR_DrawPic (icon_x+icon_offset+5, icon_y+2, 32, 32,  ALIGN_CENTER, false, scratch, 1.0);
 }
 
 

ui/ui_mp_startserver.c

@@ -476,12 +476,12 @@ void DrawStartSeverLevelshot (void)
 {
 	char *mapshotname = UI_UpdateStartSeverLevelshot (s_startmap_list.curvalue);
 
-	SCR_DrawFill (SCREEN_WIDTH/2+44, SCREEN_HEIGHT/2-70, 244, 184, ALIGN_CENTER, 60,60,60,255);
+	SCR_DrawFill (SCREEN_WIDTH/2+44, SCREEN_HEIGHT/2-70, 244, 184, ALIGN_CENTER, false, 60,60,60,255);
 
 	if (mapshotname)
-		SCR_DrawPic (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, mapshotname, 1.0);
+		SCR_DrawPic (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, false, mapshotname, 1.0);
 	else
-		SCR_DrawFill (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, 0,0,0,255);
+		SCR_DrawFill (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, false, 0,0,0,255);
 }
 #else
 void DrawStartSeverLevelshot (void)
@@ -491,7 +491,7 @@ void DrawStartSeverLevelshot (void)
 	int i = s_startmap_list.curvalue;
 	Q_strncpyz (startmap, sizeof(startmap), strchr( ui_svr_mapnames[i], '\n' ) + 1);
 
-	SCR_DrawFill (SCREEN_WIDTH/2+44, SCREEN_HEIGHT/2-70, 244, 184, ALIGN_CENTER, 60,60,60,255);
+	SCR_DrawFill (SCREEN_WIDTH/2+44, SCREEN_HEIGHT/2-70, 244, 184, ALIGN_CENTER, false, 60,60,60,255);
 
 	if ( ui_svr_mapshotvalid[i] == M_UNSET) { // init levelshot
 		Com_sprintf(mapshotname, sizeof(mapshotname), "/levelshots/%s.pcx", startmap);
@@ -504,12 +504,12 @@ void DrawStartSeverLevelshot (void)
 	if ( ui_svr_mapshotvalid[i] == M_FOUND) {
 		Com_sprintf(mapshotname, sizeof(mapshotname), "/levelshots/%s.pcx", startmap);
 
-		SCR_DrawPic (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, mapshotname, 1.0);
+		SCR_DrawPic (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, false, mapshotname, 1.0);
 	}
 	else if (ui_svr_mapshotvalid[ui_svr_nummaps] == M_FOUND)
-		SCR_DrawPic (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, "/gfx/ui/noscreen.pcx", 1.0);
+		SCR_DrawPic (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, false, "/gfx/ui/noscreen.pcx", 1.0);
 	else
-		SCR_DrawFill (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, 0,0,0,255);
+		SCR_DrawFill (SCREEN_WIDTH/2+46, SCREEN_HEIGHT/2-68, 240, 180, ALIGN_CENTER, false, 0,0,0,255);
 }
 #endif
 

ui/ui_options_interface.c

@@ -79,14 +79,14 @@ static void AltTextColorFunc( void *unused )
 // Psychospaz's transparent console
 static void ConAlphaFunc( void *unused )
 {
-//	Cvar_SetValue( "con_alpha", s_options_interface_conalpha_slider.curvalue * 0.05 );
+//	Cvar_SetValue( "scr_conalpha", s_options_interface_conalpha_slider.curvalue * 0.05 );
-	Cvar_SetValue( "con_alpha", MenuSlider_GetValue(&s_options_interface_conalpha_slider) );
+	Cvar_SetValue( "scr_conalpha", MenuSlider_GetValue(&s_options_interface_conalpha_slider) );
 }
 
 // variable console height
 /*static void ConHeightFunc( void *unused )
 {
-	Cvar_SetValue( "con_height", 0.25 + (s_options_interface_conheight_slider.curvalue * 0.05) );
+	Cvar_SetValue( "scr_conheight", 0.25 + (s_options_interface_conheight_slider.curvalue * 0.05) );
 }*/
 
 static void SimpleLoadscreenFunc( void *unused )
@@ -96,7 +96,7 @@ static void SimpleLoadscreenFunc( void *unused )
 
 static void NewConbackFunc( void *unused )
 {
-	Cvar_SetValue( "con_newconback", s_options_interface_newconback_box.curvalue );
+	Cvar_SetValue( "scr_newconback", s_options_interface_newconback_box.curvalue );
 }
 
 static void NoAltTabFunc( void *unused )
@@ -185,19 +185,19 @@ static void InterfaceSetMenuItemValues (void)
 	Cvar_SetValue( "alt_text_color", ClampCvar( 0, 9, Cvar_VariableValue("alt_text_color") ) );
 	s_options_interface_alt_text_color_box.curvalue	= Cvar_VariableValue("alt_text_color");
 
-	Cvar_SetValue( "con_alpha", ClampCvar( 0, 1, Cvar_VariableValue("con_alpha") ) );
+	Cvar_SetValue( "scr_conalpha", ClampCvar( 0, 1, Cvar_VariableValue("scr_conalpha") ) );
-//	s_options_interface_conalpha_slider.curvalue		= ( Cvar_VariableValue("con_alpha") ) * 20;
+//	s_options_interface_conalpha_slider.curvalue		= ( Cvar_VariableValue("scr_conalpha") ) * 20;
-	MenuSlider_SetValue (&s_options_interface_conalpha_slider, Cvar_VariableValue("con_alpha"));
+	MenuSlider_SetValue (&s_options_interface_conalpha_slider, Cvar_VariableValue("scr_conalpha"));
 
-//	Cvar_SetValue( "con_height", ClampCvar( 0.25, 0.75, Cvar_VariableValue("con_height") ) );
+//	Cvar_SetValue( "scr_conheight", ClampCvar( 0.25, 0.75, Cvar_VariableValue("scr_conheight") ) );
-//	s_options_interface_conheight_slider.curvalue		= 20 * (Cvar_VariableValue("con_height") - 0.25);
+//	s_options_interface_conheight_slider.curvalue		= 20 * (Cvar_VariableValue("scr_conheight") - 0.25);
-//	MenuSlider_SetValue (&s_options_interface_conheight_slider, Cvar_VariableValue("con_height"));
+//	MenuSlider_SetValue (&s_options_interface_conheight_slider, Cvar_VariableValue("scr_conheight"));
 
 	Cvar_SetValue( "scr_simple_loadscreen", ClampCvar( 0, 1, Cvar_VariableValue("scr_simple_loadscreen") ) );
 	s_options_interface_simple_loadscreen_box.curvalue = Cvar_VariableValue("scr_simple_loadscreen");
 
-	Cvar_SetValue( "con_newconback", ClampCvar( 0, 1, Cvar_VariableValue("con_newconback") ) );
+	Cvar_SetValue( "scr_newconback", ClampCvar( 0, 1, Cvar_VariableValue("scr_newconback") ) );
-	s_options_interface_newconback_box.curvalue = Cvar_VariableValue("con_newconback");
+	s_options_interface_newconback_box.curvalue = Cvar_VariableValue("scr_newconback");
 
 	s_options_interface_noalttab_box.curvalue			= Cvar_VariableValue("win_noalttab");
 }
@@ -211,10 +211,10 @@ static void InterfaceResetDefaultsFunc (void *unused)
 	Cvar_SetToDefault ("ui_font");	
 	Cvar_SetToDefault ("scr_font");	
 	Cvar_SetToDefault ("alt_text_color");	
-	Cvar_SetToDefault ("con_alpha");	
+	Cvar_SetToDefault ("scr_alpha");	
-//	Cvar_SetToDefault ("con_height");	
+//	Cvar_SetToDefault ("scr_height");	
 	Cvar_SetToDefault ("scr_simple_loadscreen");
-	Cvar_SetToDefault ("con_newconback");
+	Cvar_SetToDefault ("scr_newconback");
 	Cvar_SetToDefault ("win_noalttab");	
 
 	InterfaceSetMenuItemValues ();

ui/ui_options_keys.c

@@ -127,18 +127,33 @@ static void M_FindKeysForCommand (char *command, int *twokeys)
 
 static void KeysBackCursorDrawFunc (menuaction_s *self) // back action
 {
-	SCR_DrawChar (SCREEN_WIDTH*0.5 - 24, s_keys_menu.y + self->generic.y, MENU_FONT_SIZE, ALIGN_CENTER,
+	char	*cursor;
+
+	cursor = ((int)(Sys_Milliseconds()/250)&1) ? UI_ITEMCURSOR_DEFAULT_PIC : UI_ITEMCURSOR_BLINK_PIC;
+
+	SCR_DrawPic (SCREEN_WIDTH*0.5 - 24, s_keys_menu.y + self->generic.y, MENU_FONT_SIZE, MENU_FONT_SIZE, ALIGN_CENTER, false, cursor, 255);
+/*	SCR_DrawChar (SCREEN_WIDTH*0.5 - 24, s_keys_menu.y + self->generic.y, MENU_FONT_SIZE, ALIGN_CENTER,
 					12+((int)(Sys_Milliseconds()/250)&1), FONT_UI, 255,255,255,255, false, true);
+*/
 }
 
 static void KeyCursorDrawFunc (menuframework_s *menu)
 {
+	char	*cursor;
+
 	if (bind_grab)
+		cursor = UI_ITEMCURSOR_KEYBIND_PIC;
+	else
+		cursor = ((int)(Sys_Milliseconds()/250)&1) ? UI_ITEMCURSOR_DEFAULT_PIC : UI_ITEMCURSOR_BLINK_PIC;
+
+	SCR_DrawPic (menu->x, menu->y + menu->cursor * MENU_LINE_SIZE, MENU_FONT_SIZE, MENU_FONT_SIZE, ALIGN_CENTER, false, cursor, 255);
+/*	if (bind_grab)
 		SCR_DrawChar (menu->x, menu->y + menu->cursor * MENU_LINE_SIZE, MENU_FONT_SIZE, ALIGN_CENTER,
 						'=', FONT_UI, 255,255,255,255, false, true);
 	else
 		SCR_DrawChar (menu->x, menu->y + menu->cursor * MENU_LINE_SIZE, MENU_FONT_SIZE, ALIGN_CENTER,
 						12+((int)(Sys_Milliseconds()/250)&1), FONT_UI, 255,255,255,255, false, true);
+*/
 }
 
 static void DrawKeyBindingFunc (void *self)

ui/ui_options_screen.c

@@ -393,15 +393,15 @@ void MenuCrosshair_MouseClick ( void )
 void DrawMenuCrosshair (void)
 {
 	SCR_DrawFill (SCREEN_WIDTH*0.5 - 18, s_options_screen_menu.y + 42,
-					36, 36, ALIGN_CENTER, 60,60,60,255);
+					36, 36, ALIGN_CENTER, false, 60,60,60,255);
 	SCR_DrawFill (SCREEN_WIDTH*0.5 - 17, s_options_screen_menu.y + 43,
-					34, 34, ALIGN_CENTER,  0,0,0,255);
+					34, 34, ALIGN_CENTER,  false, 0,0,0,255);
 
 	if (s_options_screen_crosshair_box.curvalue < 1)
 		return;
 
 	SCR_DrawPic (SCREEN_WIDTH*0.5-16, s_options_screen_menu.y + 44,
-					32, 32, ALIGN_CENTER, ui_crosshair_names[s_options_screen_crosshair_box.curvalue], 1.0);
+					32, 32, ALIGN_CENTER, false, ui_crosshair_names[s_options_screen_crosshair_box.curvalue], 1.0);
 }
 
 void Options_Screen_MenuDraw (void)

ui/ui_options_sound.c

@@ -73,7 +73,7 @@ static void UpdateCDVolumeFunc ( void *unused )
 
 static void UpdateSoundQualityFunc ( void *unused )
 {
-	//Knightmare- added DMP's 44/48 KHz sound support
+	// Knightmare- added DMP's 44/48 KHz sound support
 	//** DMP check the newly added sound quality menu options
 	switch (s_options_sound_quality_list.curvalue)
 	{

ui/ui_quit.c

@@ -127,7 +127,7 @@ void M_Quit_Draw (void)
 	int		w, h;
 
 	R_DrawGetPicSize (&w, &h, "quit");
-	SCR_DrawPic (SCREEN_WIDTH/2-w/2, SCREEN_HEIGHT/2-h/2, w, h, ALIGN_CENTER, "quit", 1.0);
+	SCR_DrawPic (SCREEN_WIDTH/2-w/2, SCREEN_HEIGHT/2-h/2, w, h, ALIGN_CENTER, false, "quit", 1.0);
 #endif // QUITMENU_NOKEY
 }
 

ui/ui_subsystem.c

@@ -34,6 +34,13 @@ cvar_t	*ui_background_alpha;
 cvar_t	*ui_item_rotate;
 cvar_t	*ui_cursor_scale;
 
+// moved these here to avoid redundancy
+char *menu_null_sound		= "null";
+char *menu_in_sound			= "misc/menu1.wav";
+char *menu_move_sound		= "misc/menu2.wav";
+char *menu_out_sound		= "misc/menu3.wav";
+char *menu_drag_sound		= "drag";
+
 qboolean	ui_entersound;		// play after drawing a frame, so caching
 								// won't disrupt the sound
 qboolean	ui_initialized = false;	// whether UI subsystem has been initialized
@@ -393,6 +400,9 @@ void UI_Precache (void)
 //	R_DrawFindPic (UI_MOUSECURSOR_OVER_PIC);
 //	R_DrawFindPic (UI_MOUSECURSOR_TEXT_PIC);
 	R_DrawFindPic (UI_MOUSECURSOR_PIC);
+	R_DrawFindPic (UI_ITEMCURSOR_DEFAULT_PIC);
+	R_DrawFindPic (UI_ITEMCURSOR_KEYBIND_PIC);
+	R_DrawFindPic (UI_ITEMCURSOR_BLINK_PIC);
 
 	for (i = 0; i < NUM_MAINMENU_CURSOR_FRAMES; i++) {
 		Com_sprintf (scratch, sizeof(scratch), "/pics/m_cursor%d.pcx", i);
@@ -434,11 +444,19 @@ void UI_Precache (void)
 //	R_DrawFindPic ("/pics/yn.pcx");
 
 	// GUI elements
-	R_DrawFindPic ("/gfx/ui/listbox_background.pcx");
+	R_DrawFindPic ("/gfx/ui/widgets/listbox_background.pcx");
-	R_DrawFindPic ("/gfx/ui/arrows/arrow_left.pcx");
+//	R_DrawFindPic (UI_CHECKBOX_ON_PIC);
-	R_DrawFindPic ("/gfx/ui/arrows/arrow_left_d.pcx");
+//	R_DrawFindPic (UI_CHECKBOX_OFF_PIC);
-	R_DrawFindPic ("/gfx/ui/arrows/arrow_right.pcx");
+	R_DrawFindPic (UI_FIELD_PIC);
-	R_DrawFindPic ("/gfx/ui/arrows/arrow_right_d.pcx"); 
+	R_DrawFindPic (UI_TEXTBOX_PIC);
+	R_DrawFindPic (UI_SLIDER_PIC);
+	R_DrawFindPic (UI_ARROWS_PIC);
+
+//	R_DrawFindPic ("/gfx/ui/listbox_background.pcx");
+//	R_DrawFindPic ("/gfx/ui/arrows/arrow_left.pcx");
+//	R_DrawFindPic ("/gfx/ui/arrows/arrow_left_d.pcx");
+//	R_DrawFindPic ("/gfx/ui/arrows/arrow_right.pcx");
+//	R_DrawFindPic ("/gfx/ui/arrows/arrow_right_d.pcx"); 
 }
 
 
@@ -561,7 +579,7 @@ void UI_Draw (void)
 		{
 		//	R_DrawStretchPic (0, 0, viddef.width, viddef.height, UI_BACKGROUND_NAME, 1.0f);
 			R_DrawFill (0,0,viddef.width, viddef.height, 0 ,0, 0, 255);
-			SCR_DrawPic(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_CENTER, UI_BACKGROUND_NAME, 1.0f);
+			SCR_DrawPic(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_CENTER, false, UI_BACKGROUND_NAME, 1.0f);
 		}
 		else
 			R_DrawFill (0,0,viddef.width, viddef.height, 0, 0, 0, 255);
@@ -569,7 +587,7 @@ void UI_Draw (void)
 	// ingame menu uses alpha
 	else if (R_DrawFindPic(UI_BACKGROUND_NAME))
 	//	R_DrawStretchPic (0, 0, viddef.width, viddef.height, UI_BACKGROUND_NAME, ui_background_alpha->value);
-		SCR_DrawPic(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_CENTER, UI_BACKGROUND_NAME, ui_background_alpha->value);
+		SCR_DrawPic(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ALIGN_CENTER, false, UI_BACKGROUND_NAME, ui_background_alpha->value);
 	else
 		R_DrawFill (0,0,viddef.width, viddef.height, 0, 0, 0, (int)(ui_background_alpha->value*255.0f));