1204 lines
25 KiB
C
1204 lines
25 KiB
C
//-----------------------------------------------------------------------------
|
|
//
|
|
// $Id$
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// $Log: cg_drawtools.c,v $
|
|
// Revision 1.13 2005/02/15 16:33:38 makro
|
|
// Tons of updates (entity tree attachment system, UI vectors)
|
|
//
|
|
// Revision 1.12 2004/01/26 21:26:08 makro
|
|
// no message
|
|
//
|
|
// Revision 1.11 2002/08/07 04:45:46 niceass
|
|
// ctb changes
|
|
//
|
|
// Revision 1.10 2002/06/16 20:06:13 jbravo
|
|
// Reindented all the source files with "indent -kr -ut -i8 -l120 -lc120 -sob -bad -bap"
|
|
//
|
|
// Revision 1.9 2002/03/24 22:48:57 niceass
|
|
// cg_draw change for scoreboard
|
|
//
|
|
// Revision 1.8 2002/02/04 00:22:50 niceass
|
|
// Added DrawCleanBox for scoreboard
|
|
//
|
|
// Revision 1.7 2002/01/11 19:48:29 jbravo
|
|
// Formatted the source in non DOS format.
|
|
//
|
|
// Revision 1.6 2001/12/31 16:28:41 jbravo
|
|
// I made a Booboo with the Log tag.
|
|
//
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
// Copyright (C) 1999-2000 Id Software, Inc.
|
|
//
|
|
// cg_drawtools.c -- helper functions called by cg_draw, cg_scoreboard, cg_info, etc
|
|
#include "cg_local.h"
|
|
|
|
/*
|
|
================
|
|
CG_AdjustFrom640
|
|
|
|
Adjusted for resolution and screen aspect ratio
|
|
================
|
|
*/
|
|
void CG_AdjustFrom640(float *x, float *y, float *w, float *h)
|
|
{
|
|
// scale for screen sizes
|
|
*x = *x * cgs.screenXScale + cgs.screenXBias;
|
|
*y *= cgs.screenYScale;
|
|
*w *= cgs.screenXScale;
|
|
*h *= cgs.screenYScale;
|
|
}
|
|
|
|
/*
|
|
================
|
|
CG_FillRect
|
|
|
|
Coordinates are 640*480 virtual values
|
|
=================
|
|
*/
|
|
void CG_FillRect(float x, float y, float width, float height, const float *color)
|
|
{
|
|
trap_R_SetColor(color);
|
|
|
|
CG_AdjustFrom640(&x, &y, &width, &height);
|
|
trap_R_DrawStretchPic(x, y, width, height, 0, 0, 0, 0, cgs.media.whiteShader);
|
|
|
|
trap_R_SetColor(NULL);
|
|
}
|
|
|
|
/*
|
|
================
|
|
CG_DrawSides
|
|
|
|
Coords are virtual 640x480
|
|
================
|
|
*/
|
|
void CG_DrawSides(float x, float y, float w, float h, float size)
|
|
{
|
|
CG_AdjustFrom640(&x, &y, &w, &h);
|
|
size *= cgs.screenXScale;
|
|
trap_R_DrawStretchPic(x, y, size, h, 0, 0, 0, 0, cgs.media.whiteShader);
|
|
trap_R_DrawStretchPic(x + w - size, y, size, h, 0, 0, 0, 0, cgs.media.whiteShader);
|
|
}
|
|
|
|
void CG_DrawTopBottom(float x, float y, float w, float h, float size)
|
|
{
|
|
CG_AdjustFrom640(&x, &y, &w, &h);
|
|
size *= cgs.screenYScale;
|
|
trap_R_DrawStretchPic(x, y, w, size, 0, 0, 0, 0, cgs.media.whiteShader);
|
|
trap_R_DrawStretchPic(x, y + h - size, w, size, 0, 0, 0, 0, cgs.media.whiteShader);
|
|
}
|
|
|
|
/*
|
|
================
|
|
CG_DrawCleanTopBottom -- Added by NiceAss
|
|
"Size" not scaled
|
|
|
|
Coordinates are 640*480 virtual values
|
|
=================
|
|
*/
|
|
void CG_DrawCleanSides(float x, float y, float w, float h, float size, const float *color)
|
|
{
|
|
CG_AdjustFrom640(&x, &y, &w, &h);
|
|
trap_R_SetColor(color);
|
|
trap_R_DrawStretchPic(x, y, size, h, 0, 0, 0, 0, cgs.media.whiteShader);
|
|
trap_R_DrawStretchPic(x + w - size, y, size, h, 0, 0, 0, 0, cgs.media.whiteShader);
|
|
trap_R_SetColor(NULL);
|
|
}
|
|
|
|
void CG_DrawCleanLine(float x, float y, float w, float size, const float *color)
|
|
{
|
|
float h = 0;
|
|
|
|
CG_AdjustFrom640(&x, &y, &w, &h);
|
|
trap_R_SetColor(color);
|
|
trap_R_DrawStretchPic(x, y, w, size, 0, 0, 0, 0, cgs.media.whiteShader);
|
|
trap_R_SetColor(NULL);
|
|
}
|
|
|
|
/*
|
|
================
|
|
UI_DrawRect
|
|
|
|
Coordinates are 640*480 virtual values
|
|
=================
|
|
*/
|
|
void CG_DrawRect(float x, float y, float width, float height, float size, const float *color)
|
|
{
|
|
trap_R_SetColor(color);
|
|
|
|
CG_DrawTopBottom(x, y, width, height, size);
|
|
CG_DrawSides(x, y + size, width, height - size * 2, size);
|
|
|
|
trap_R_SetColor(NULL);
|
|
}
|
|
|
|
void CG_DrawFuzzyRect(float x, float y, float w, float h, float corner, vec4_t color, qhandle_t shader)
|
|
{
|
|
float xcorner = corner * cgs.screenXScale;
|
|
float ycorner = corner * cgs.screenYScale;
|
|
|
|
CG_AdjustFrom640(&x, &y, &w, &h);
|
|
if (xcorner + xcorner > w)
|
|
xcorner = w * 0.5f;
|
|
if (ycorner + ycorner > h)
|
|
ycorner = h * 0.5f;
|
|
|
|
trap_R_SetColor(color);
|
|
|
|
// top //
|
|
trap_R_DrawStretchPic(x, y, xcorner, ycorner, 0, 0, 0.5f, 0.5f, shader);
|
|
trap_R_DrawStretchPic(x+xcorner, y, w-xcorner-xcorner, ycorner, 0.5f, 0, 0.5f, 0.5f, shader);
|
|
trap_R_DrawStretchPic(x+w-xcorner, y, xcorner, ycorner, 0.5f, 0, 1, 0.5f, shader);
|
|
|
|
// middle //
|
|
trap_R_DrawStretchPic(x, y+ycorner, xcorner, h-ycorner-ycorner, 0, 0.5f, 0.5f, 0.5f, shader);
|
|
trap_R_DrawStretchPic(x+xcorner, y+ycorner, w-xcorner-xcorner, h-ycorner-ycorner, 0.5f, 0.5f, 0.5f, 0.5f, shader);
|
|
trap_R_DrawStretchPic(x+w-xcorner, y+ycorner, xcorner, h-ycorner-ycorner, 0.5f, 0.5f, 1, 0.5f, shader);
|
|
|
|
// bottom //
|
|
trap_R_DrawStretchPic(x, y+h-ycorner, xcorner, ycorner, 0, 0.5f, 0.5f, 1, shader);
|
|
trap_R_DrawStretchPic(x+xcorner, y+h-ycorner, w-xcorner-xcorner, ycorner, 0.5f, 0.5f, 0.5f, 1, shader);
|
|
trap_R_DrawStretchPic(x+w-xcorner, y+h-ycorner, xcorner, ycorner, 0.5f, 0.5f, 1, 1, shader);
|
|
|
|
trap_R_SetColor(NULL);
|
|
}
|
|
|
|
void CG_DrawFuzzyShadow(float x, float y, float w, float h, float corner, float alpha)
|
|
{
|
|
vec4_t color;
|
|
color[0] = color[1] = color[2] = alpha;
|
|
color[3] = 1.f;
|
|
CG_DrawFuzzyRect(x, y, w, h, corner, color, cgs.media.fuzzyShadowShader);
|
|
}
|
|
|
|
void CG_DrawFuzzyGlow(float x, float y, float w, float h, float corner, vec4_t color)
|
|
{
|
|
CG_DrawFuzzyRect(x, y, w, h, corner, color, cgs.media.fuzzyGlowShader);
|
|
}
|
|
|
|
|
|
/*
|
|
================
|
|
UI_DrawRect -- Added by NiceAss
|
|
"Size" not scaled
|
|
|
|
Coordinates are 640*480 virtual values
|
|
=================
|
|
*/
|
|
void CG_DrawCleanRect(float x, float y, float width, float height, float size, const float *color)
|
|
{
|
|
CG_AdjustFrom640(&x, &y, &width, &height);
|
|
trap_R_SetColor(color);
|
|
trap_R_DrawStretchPic(x, y, size, height, 0, 0, 0, 0, cgs.media.whiteShader);
|
|
trap_R_DrawStretchPic(x + width - size, y, size, height, 0, 0, 0, 0, cgs.media.whiteShader);
|
|
trap_R_DrawStretchPic(x, y, width, size, 0, 0, 0, 0, cgs.media.whiteShader);
|
|
trap_R_DrawStretchPic(x, y + height - size, width, size, 0, 0, 0, 0, cgs.media.whiteShader);
|
|
trap_R_SetColor(NULL);
|
|
}
|
|
|
|
/*
|
|
================
|
|
CG_DrawPic
|
|
|
|
Coordinates are 640*480 virtual values
|
|
=================
|
|
*/
|
|
void CG_DrawPic(float x, float y, float width, float height, qhandle_t hShader)
|
|
{
|
|
CG_AdjustFrom640(&x, &y, &width, &height);
|
|
trap_R_DrawStretchPic(x, y, width, height, 0, 0, 1, 1, hShader);
|
|
}
|
|
|
|
/*
|
|
===============
|
|
CG_DrawChar
|
|
|
|
Coordinates and size in 640*480 virtual screen size
|
|
===============
|
|
*/
|
|
void CG_DrawChar(int x, int y, int width, int height, int ch)
|
|
{
|
|
int row, col;
|
|
float frow, fcol;
|
|
float size;
|
|
float ax, ay, aw, ah;
|
|
|
|
ch &= 255;
|
|
|
|
if (ch == ' ' || ch == '\t' || ch == '\n') {
|
|
return;
|
|
}
|
|
|
|
ax = x;
|
|
ay = y;
|
|
aw = width;
|
|
ah = height;
|
|
CG_AdjustFrom640(&ax, &ay, &aw, &ah);
|
|
|
|
row = ch >> 4;
|
|
col = ch & 15;
|
|
|
|
frow = row * 0.0625;
|
|
fcol = col * 0.0625;
|
|
size = 0.0625;
|
|
|
|
trap_R_DrawStretchPic(ax, ay, aw, ah, fcol, frow, fcol + size, frow + size, cgs.media.charsetShader);
|
|
}
|
|
|
|
/*
|
|
==================
|
|
CG_DrawStringExt
|
|
|
|
Draws a multi-colored string with a drop shadow, optionally forcing
|
|
to a fixed color.
|
|
|
|
Coordinates are at 640 by 480 virtual resolution
|
|
==================
|
|
*/
|
|
void CG_DrawStringExt(int x, int y, const char *string, const float *setColor,
|
|
qboolean forceColor, qboolean shadow, int charWidth, int charHeight, int maxChars)
|
|
{
|
|
//Makro - for underlined chars
|
|
int yoffset = y + charHeight * 0.25f;
|
|
qboolean underlined = qfalse;
|
|
vec4_t color;
|
|
const char *s;
|
|
int xx;
|
|
int cnt;
|
|
|
|
if (maxChars <= 0)
|
|
maxChars = 32767; // do them all!
|
|
|
|
// draw the drop shadow
|
|
if (shadow) {
|
|
color[0] = color[1] = color[2] = 0;
|
|
color[3] = setColor[3];
|
|
trap_R_SetColor(color);
|
|
s = string;
|
|
xx = x;
|
|
cnt = 0;
|
|
while (*s && cnt < maxChars) {
|
|
if (Q_IsColorString(s)) {
|
|
s += 2;
|
|
continue;
|
|
}
|
|
if (*s == '\n')
|
|
{
|
|
xx = x;
|
|
y += charHeight;
|
|
yoffset += charHeight;
|
|
++s;
|
|
continue;
|
|
}
|
|
CG_DrawChar(xx + 1, y + 1, charWidth, charHeight, *s);
|
|
cnt++;
|
|
xx += charWidth;
|
|
s++;
|
|
}
|
|
}
|
|
// draw the colored text
|
|
s = string;
|
|
xx = x;
|
|
cnt = 0;
|
|
trap_R_SetColor(setColor);
|
|
while (*s && cnt < maxChars) {
|
|
if (Q_IsColorString(s)) {
|
|
if (!forceColor) {
|
|
//Makro - new tricks
|
|
if (*(s+1) == '*')
|
|
{
|
|
memcpy(color, setColor, sizeof(color));
|
|
trap_R_SetColor(color);
|
|
} else if (*(s+1)== '_')
|
|
{
|
|
underlined ^= qtrue;
|
|
} else {
|
|
memcpy(color, g_color_table[ColorIndex(*(s + 1))], sizeof(color));
|
|
color[3] = setColor[3];
|
|
trap_R_SetColor(color);
|
|
}
|
|
}
|
|
s += 2;
|
|
continue;
|
|
}
|
|
if (*s == '\n')
|
|
{
|
|
xx = x;
|
|
y += charHeight;
|
|
yoffset += charHeight;
|
|
++s;
|
|
continue;
|
|
}
|
|
CG_DrawChar(xx, y, charWidth, charHeight, *s);
|
|
if (underlined)
|
|
{
|
|
CG_DrawChar(xx, yoffset, charWidth, charHeight, '_');
|
|
}
|
|
xx += charWidth;
|
|
cnt++;
|
|
s++;
|
|
}
|
|
trap_R_SetColor(NULL);
|
|
}
|
|
|
|
void CG_DrawBigString(int x, int y, const char *s, float alpha)
|
|
{
|
|
float color[4];
|
|
|
|
color[0] = color[1] = color[2] = 1.0;
|
|
color[3] = alpha;
|
|
CG_DrawStringExt(x, y, s, color, qfalse, qtrue, BIGCHAR_WIDTH, BIGCHAR_HEIGHT, 0);
|
|
}
|
|
|
|
void CG_DrawBigStringColor(int x, int y, const char *s, vec4_t color)
|
|
{
|
|
CG_DrawStringExt(x, y, s, color, qtrue, qtrue, BIGCHAR_WIDTH, BIGCHAR_HEIGHT, 0);
|
|
}
|
|
|
|
void CG_DrawSmallString(int x, int y, const char *s, float alpha)
|
|
{
|
|
float color[4];
|
|
|
|
color[0] = color[1] = color[2] = 1.0;
|
|
color[3] = alpha;
|
|
CG_DrawStringExt(x, y, s, color, qfalse, qfalse, SMALLCHAR_WIDTH, SMALLCHAR_HEIGHT, 0);
|
|
}
|
|
|
|
void CG_DrawSmallStringColor(int x, int y, const char *s, vec4_t color)
|
|
{
|
|
CG_DrawStringExt(x, y, s, color, qtrue, qfalse, SMALLCHAR_WIDTH, SMALLCHAR_HEIGHT, 0);
|
|
}
|
|
|
|
/*
|
|
=================
|
|
CG_DrawStrlen
|
|
|
|
Returns character count, skiping color escape codes
|
|
=================
|
|
*/
|
|
int CG_DrawStrlen(const char *str)
|
|
{
|
|
const char *s = str;
|
|
int count = 0;
|
|
int max = 0;
|
|
|
|
if (!str)
|
|
return 0;
|
|
|
|
while (*s) {
|
|
if (Q_IsColorString(s)) {
|
|
s += 2;
|
|
} else {
|
|
if (*s == '\n')
|
|
{
|
|
max = count > max ? count : max;
|
|
count = 0;
|
|
++s;
|
|
continue;
|
|
}
|
|
count++;
|
|
s++;
|
|
}
|
|
}
|
|
|
|
max = count > max ? count : max;
|
|
|
|
return max;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
CG_TileClearBox
|
|
|
|
This repeats a 64*64 tile graphic to fill the screen around a sized down
|
|
refresh window.
|
|
=============
|
|
*/
|
|
static void CG_TileClearBox(int x, int y, int w, int h, qhandle_t hShader)
|
|
{
|
|
float s1, t1, s2, t2;
|
|
|
|
s1 = x / 64.0;
|
|
t1 = y / 64.0;
|
|
s2 = (x + w) / 64.0;
|
|
t2 = (y + h) / 64.0;
|
|
trap_R_DrawStretchPic(x, y, w, h, s1, t1, s2, t2, hShader);
|
|
}
|
|
|
|
/*
|
|
==============
|
|
CG_TileClear
|
|
|
|
Clear around a sized down screen
|
|
==============
|
|
*/
|
|
void CG_TileClear(void)
|
|
{
|
|
int top, bottom, left, right;
|
|
int w, h;
|
|
|
|
w = cgs.glconfig.vidWidth;
|
|
h = cgs.glconfig.vidHeight;
|
|
|
|
if (cg.refdef.x == 0 && cg.refdef.y == 0 && cg.refdef.width == w && cg.refdef.height == h) {
|
|
return; // full screen rendering
|
|
}
|
|
|
|
top = cg.refdef.y;
|
|
bottom = top + cg.refdef.height - 1;
|
|
left = cg.refdef.x;
|
|
right = left + cg.refdef.width - 1;
|
|
|
|
// clear above view screen
|
|
CG_TileClearBox(0, 0, w, top, cgs.media.backTileShader);
|
|
|
|
// clear below view screen
|
|
CG_TileClearBox(0, bottom, w, h - bottom, cgs.media.backTileShader);
|
|
|
|
// clear left of view screen
|
|
CG_TileClearBox(0, top, left, bottom - top + 1, cgs.media.backTileShader);
|
|
|
|
// clear right of view screen
|
|
CG_TileClearBox(right, top, w - right, bottom - top + 1, cgs.media.backTileShader);
|
|
}
|
|
|
|
/*
|
|
================
|
|
CG_FadeColor
|
|
================
|
|
*/
|
|
float *CG_FadeColor(int startMsec, int totalMsec)
|
|
{
|
|
static vec4_t color;
|
|
int t;
|
|
|
|
if (startMsec == 0) {
|
|
return NULL;
|
|
}
|
|
|
|
t = cg.time - startMsec;
|
|
|
|
if (t >= totalMsec) {
|
|
return NULL;
|
|
}
|
|
// fade out
|
|
if (totalMsec - t < FADE_TIME) {
|
|
color[3] = (totalMsec - t) * 1.0 / FADE_TIME;
|
|
} else {
|
|
color[3] = 1.0;
|
|
}
|
|
color[0] = color[1] = color[2] = 1;
|
|
|
|
return color;
|
|
}
|
|
|
|
/*
|
|
================
|
|
CG_TeamColor
|
|
================
|
|
*/
|
|
void CG_TeamColor(int team, float *color)
|
|
{
|
|
if ( cgs.gametype == GT_CTF ) {
|
|
switch (team) {
|
|
case TEAM_RED:
|
|
MAKERGBA(color, 0.5f, 0.5f, 0.5f, 1);
|
|
break;
|
|
case TEAM_BLUE:
|
|
MAKERGBA(color, 0, 0, 0, 1);
|
|
break;
|
|
default:
|
|
MAKERGBA(color, 1, 1, 1, 1);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (team) {
|
|
case TEAM_RED:
|
|
MAKERGBA(color, 1, 0, 0, 1);
|
|
break;
|
|
case TEAM_BLUE:
|
|
MAKERGBA(color, 0, 0, 1, 1);
|
|
break;
|
|
default:
|
|
MAKERGBA(color, 1, 1, 1, 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
=================
|
|
CG_GetColorForHealth
|
|
=================
|
|
*/
|
|
void CG_GetColorForHealth(int health, int armor, vec4_t hcolor)
|
|
{
|
|
int count;
|
|
int max;
|
|
|
|
// calculate the total points of damage that can
|
|
// be sustained at the current health / armor level
|
|
if (health <= 0) {
|
|
VectorClear(hcolor); // black
|
|
hcolor[3] = 1;
|
|
return;
|
|
}
|
|
count = armor;
|
|
max = health * ARMOR_PROTECTION / (1.0 - ARMOR_PROTECTION);
|
|
if (max < count) {
|
|
count = max;
|
|
}
|
|
health += count;
|
|
|
|
// set the color based on health
|
|
hcolor[0] = 1.0;
|
|
hcolor[3] = 1.0;
|
|
if (health >= 100) {
|
|
hcolor[2] = 1.0;
|
|
} else if (health < 66) {
|
|
hcolor[2] = 0;
|
|
} else {
|
|
hcolor[2] = (health - 66) / 33.0;
|
|
}
|
|
|
|
if (health > 60) {
|
|
hcolor[1] = 1.0;
|
|
} else if (health < 30) {
|
|
hcolor[1] = 0;
|
|
} else {
|
|
hcolor[1] = (health - 30) / 30.0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=================
|
|
CG_ColorForHealth
|
|
=================
|
|
*/
|
|
void CG_ColorForHealth(vec4_t hcolor)
|
|
{
|
|
|
|
CG_GetColorForHealth(cg.snap->ps.stats[STAT_HEALTH], cg.snap->ps.stats[STAT_ARMOR], hcolor);
|
|
}
|
|
|
|
/*
|
|
=================
|
|
UI_DrawProportionalString2
|
|
=================
|
|
*/
|
|
static int propMap[128][3] = {
|
|
{0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1},
|
|
{0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1},
|
|
|
|
{0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1},
|
|
{0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1}, {0, 0, -1},
|
|
|
|
//Makro - new map
|
|
/*
|
|
//Elder: new map
|
|
|
|
{0, 0, PROP_SPACE_WIDTH}, // SPACE
|
|
{3, 120, 8}, // !
|
|
{145, 168, 9}, // "
|
|
{38, 120, 15}, // #
|
|
{54, 120, 26}, // $
|
|
{81, 120, 21}, // %
|
|
{138, 120, 26}, // &
|
|
{128, 168, 5}, // '
|
|
{207, 120, 9}, // (
|
|
{228, 120, 9}, // )
|
|
{182, 120, 12}, // *
|
|
{30, 144, 15}, // +
|
|
{74, 168, 7}, // ,
|
|
{37, 96, 10}, // -
|
|
{98, 168, 8}, // .
|
|
{118, 144, 19}, // /
|
|
|
|
{230, 72, 25}, // 0
|
|
{1, 72, 21}, // 1
|
|
{26, 72, 25}, // 2
|
|
{52, 72, 25}, // 3
|
|
{78, 72, 24}, // 4
|
|
{102, 72, 26}, // 5
|
|
{128, 72, 25}, // 6
|
|
{153, 72, 25}, // 7
|
|
{178, 72, 26}, // 8
|
|
{204, 72, 25}, // 9
|
|
{55, 168, 8}, // :
|
|
{29, 168, 9}, // ;
|
|
{195, 168, 14}, // <
|
|
{59, 96, 19}, // =
|
|
{219, 168, 14}, // >
|
|
{165, 168, 24}, // ?
|
|
|
|
{14, 120, 20}, // @
|
|
{1, 0, 24}, // A
|
|
{26, 0, 24}, // B
|
|
{51, 0, 24}, // C
|
|
{77, 0, 24}, // D
|
|
{103, 0, 24}, // E
|
|
{127, 0, 24}, // F
|
|
{152, 0, 24}, // G
|
|
{178, 0, 24}, // H
|
|
{203, 0, 25}, // I
|
|
{229, 0, 24}, // J
|
|
|
|
{1, 24, 25}, // K
|
|
{27, 24, 20}, // L
|
|
{52, 24, 24}, // M
|
|
{78, 24, 24}, // N
|
|
{103, 24, 24}, // O
|
|
{128, 24, 24}, // P
|
|
{153, 24, 24}, // Q
|
|
{179, 24, 24}, // R
|
|
{205, 24, 24}, // S
|
|
{233, 24, 20}, // T
|
|
|
|
{1, 48, 25}, // U
|
|
{29, 48, 22}, // V
|
|
{54, 48, 22}, // W
|
|
{77, 48, 25}, // X
|
|
{103, 48, 24}, // Y
|
|
{128, 48, 25}, // Z
|
|
{55, 144, 13}, // [
|
|
{102, 144, 10}, // '\'
|
|
{75, 144, 13}, // ]
|
|
{115, 128, 13}, // ^ Elder: fix me in tga!!
|
|
{2, 144, 15}, // _
|
|
|
|
{134, 181, 5}, // '
|
|
//Elder: note - lowercase
|
|
{1, 0, 24}, // A
|
|
{26, 0, 24}, // B
|
|
{51, 0, 24}, // C
|
|
{77, 0, 24}, // D
|
|
{103, 0, 24}, // E
|
|
{127, 0, 24}, // F
|
|
{152, 0, 24}, // G
|
|
{178, 0, 24}, // H
|
|
{203, 0, 25}, // I
|
|
{229, 0, 24}, // J
|
|
|
|
{1, 24, 25}, // K
|
|
{27, 24, 20}, // L
|
|
{52, 24, 24}, // M
|
|
{78, 24, 24}, // N
|
|
{103, 24, 24}, // O
|
|
{128, 24, 24}, // P
|
|
{153, 24, 24}, // Q
|
|
{179, 24, 24}, // R
|
|
{205, 24, 24}, // S
|
|
{233, 24, 20}, // T
|
|
|
|
{1, 48, 25}, // U
|
|
{29, 48, 22}, // V
|
|
{54, 48, 22}, // W
|
|
{77, 48, 25}, // X
|
|
{103, 48, 24}, // Y
|
|
{128, 48, 25}, // Z
|
|
{148, 144, 11}, // {
|
|
{5, 168, 10}, // |
|
|
{169, 144, 11}, // }
|
|
{85, 96, 14}, // ~
|
|
{0, 0, -1} // DEL
|
|
};
|
|
*/
|
|
|
|
{0, 0, PROP_SPACE_WIDTH}, // SPACE
|
|
{3, 0, 36}, // !
|
|
{42, 0, 36}, // "
|
|
{81, 0, 36}, // #
|
|
{120, 0, 36}, // $
|
|
{159, 0, 16}, // %
|
|
{178, 0, 36}, // &
|
|
{217, 0, 58}, // '
|
|
{278, 0, 36}, // (
|
|
{317, 0, 58}, // )
|
|
{378, 0, 36}, // *
|
|
{417, 0, 36}, // +
|
|
{456, 0, 36}, // ,
|
|
{0, 27, 36}, // -
|
|
{39, 27, 19}, // .
|
|
{61, 27, 58}, // /
|
|
/*
|
|
{122, 27, 14}, // 0
|
|
{139, 27, 8}, // 1
|
|
{150, 27, 13}, // 2
|
|
{166, 27, 13}, // 3
|
|
{182, 27, 14}, // 4
|
|
{199, 27, 13}, // 5
|
|
{215, 27, 14}, // 6
|
|
{232, 27, 12}, // 7
|
|
{247, 27, 13}, // 8
|
|
{263, 27, 13}, // 9
|
|
*/
|
|
|
|
// TTI - new numbers
|
|
{3, 16, 114}, // 0
|
|
{133, 16, 114}, // 1
|
|
{263, 16, 114}, // 2
|
|
{394, 16, 114}, // 3
|
|
{3, 96, 114}, // 4
|
|
{133, 96, 114}, // 5
|
|
{263, 96, 114}, // 6
|
|
{394, 96, 114}, // 7
|
|
{3, 176, 114}, // 8
|
|
{133, 176, 114}, // 9
|
|
|
|
{279, 27, 11}, // :
|
|
{293, 27, 58}, // ;
|
|
{354, 27, 58}, // <
|
|
{415, 27, 36}, // =
|
|
{454, 27, 58}, // >
|
|
{0, 54, 36}, // ?
|
|
{39, 54, 36}, // @
|
|
{78, 54, 17}, // A
|
|
{98, 54, 13}, // B
|
|
{114, 54, 15}, // C
|
|
{132, 54, 16}, // D
|
|
{151, 54, 15}, // E
|
|
{169, 54, 16}, // F
|
|
{188, 54, 18}, // G
|
|
{209, 54, 20}, // H
|
|
{232, 54, 9}, // I
|
|
{244, 54, 36}, // J
|
|
{283, 54, 18}, // K
|
|
{304, 54, 15}, // L
|
|
{322, 54, 20}, // M
|
|
{345, 54, 18}, // N
|
|
{366, 54, 16}, // O
|
|
{385, 54, 16}, // P
|
|
{404, 54, 13}, // Q
|
|
{420, 54, 18}, // R
|
|
{441, 54, 14}, // S
|
|
{458, 54, 16}, // T
|
|
{477, 54, 18}, // U
|
|
{498, 54, 14}, // V
|
|
{0, 81, 18}, // W
|
|
{21, 81, 13}, // X
|
|
{37, 81, 16}, // Y
|
|
{56, 81, 36}, // Z
|
|
{95, 81, 36}, // [
|
|
{134, 81, 36}, // '\'
|
|
{173, 81, 36}, // ]
|
|
{212, 81, 36}, // ^
|
|
{251, 81, 36}, // _
|
|
{290, 81, 36}, // `
|
|
{329, 81, 18}, // a
|
|
{350, 81, 13}, // b
|
|
{366, 81, 15}, // c
|
|
{384, 81, 16}, // d
|
|
{403, 81, 15}, // e
|
|
{421, 81, 14}, // f
|
|
{438, 81, 17}, // g
|
|
{458, 81, 18}, // h
|
|
{479, 81, 11}, // i
|
|
{0, 108, 36}, // j
|
|
{39, 108, 20}, // k
|
|
{62, 108, 15}, // l
|
|
{80, 108, 19}, // m
|
|
{102, 108, 16}, // n
|
|
{121, 108, 14}, // o
|
|
{138, 108, 17}, // p
|
|
{158, 108, 13}, // q
|
|
{174, 108, 18}, // r
|
|
{195, 108, 13}, // s
|
|
{211, 108, 16}, // t
|
|
{230, 108, 15}, // u
|
|
{248, 108, 13}, // v
|
|
{264, 108, 18}, // w
|
|
{285, 108, 14}, // x
|
|
{302, 108, 16}, // y
|
|
{321, 108, 36}, // z
|
|
{360, 108, 36}, // {
|
|
{399, 108, 36}, // |
|
|
{438, 108, 36}, // }
|
|
{0, 135, 36}, // ~
|
|
{0, 0, -1} // DEL
|
|
};
|
|
|
|
/*Elder: old one
|
|
{0, 0, PROP_SPACE_WIDTH}, // SPACE
|
|
{11, 122, 7}, // !
|
|
{154, 181, 14}, // "
|
|
{55, 122, 17}, // #
|
|
{79, 122, 18}, // $
|
|
{101, 122, 23}, // %
|
|
{153, 122, 18}, // &
|
|
{9, 93, 7}, // '
|
|
{207, 122, 8}, // (
|
|
{230, 122, 9}, // )
|
|
{177, 122, 18}, // *
|
|
{30, 152, 18}, // +
|
|
{85, 181, 7}, // ,
|
|
{34, 93, 11}, // -
|
|
{110, 181, 6}, // .
|
|
{130, 152, 14}, // /
|
|
|
|
{22, 64, 17}, // 0
|
|
{41, 64, 12}, // 1
|
|
{58, 64, 17}, // 2
|
|
{78, 64, 18}, // 3
|
|
{98, 64, 19}, // 4
|
|
{120, 64, 18}, // 5
|
|
{141, 64, 18}, // 6
|
|
{204, 64, 16}, // 7
|
|
{162, 64, 17}, // 8
|
|
{182, 64, 18}, // 9
|
|
{59, 181, 7}, // :
|
|
{35,181, 7}, // ;
|
|
{203, 152, 14}, // <
|
|
{56, 93, 14}, // =
|
|
{228, 152, 14}, // >
|
|
{177, 181, 18}, // ?
|
|
|
|
{28, 122, 22}, // @
|
|
{5, 4, 18}, // A
|
|
{27, 4, 18}, // B
|
|
{48, 4, 18}, // C
|
|
{69, 4, 17}, // D
|
|
{90, 4, 13}, // E
|
|
{106, 4, 13}, // F
|
|
{121, 4, 18}, // G
|
|
{143, 4, 17}, // H
|
|
{164, 4, 8}, // I
|
|
{175, 4, 16}, // J
|
|
{195, 4, 18}, // K
|
|
{216, 4, 12}, // L
|
|
{230, 4, 23}, // M
|
|
{6, 34, 18}, // N
|
|
{27, 34, 18}, // O
|
|
|
|
{48, 34, 18}, // P
|
|
{68, 34, 18}, // Q
|
|
{90, 34, 17}, // R
|
|
{110, 34, 18}, // S
|
|
{130, 34, 14}, // T
|
|
{146, 34, 18}, // U
|
|
{166, 34, 19}, // V
|
|
{185, 34, 29}, // W
|
|
{215, 34, 18}, // X
|
|
{234, 34, 18}, // Y
|
|
{5, 64, 14}, // Z
|
|
{60, 152, 7}, // [
|
|
{106, 151, 13}, // '\'
|
|
{83, 152, 7}, // ]
|
|
{128, 122, 17}, // ^
|
|
{4, 152, 21}, // _
|
|
|
|
{134, 181, 5}, // '
|
|
{5, 4, 18}, // A
|
|
{27, 4, 18}, // B
|
|
{48, 4, 18}, // C
|
|
{69, 4, 17}, // D
|
|
{90, 4, 13}, // E
|
|
{106, 4, 13}, // F
|
|
{121, 4, 18}, // G
|
|
{143, 4, 17}, // H
|
|
{164, 4, 8}, // I
|
|
{175, 4, 16}, // J
|
|
{195, 4, 18}, // K
|
|
{216, 4, 12}, // L
|
|
{230, 4, 23}, // M
|
|
{6, 34, 18}, // N
|
|
{27, 34, 18}, // O
|
|
|
|
{48, 34, 18}, // P
|
|
{68, 34, 18}, // Q
|
|
{90, 34, 17}, // R
|
|
{110, 34, 18}, // S
|
|
{130, 34, 14}, // T
|
|
{146, 34, 18}, // U
|
|
{166, 34, 19}, // V
|
|
{185, 34, 29}, // W
|
|
{215, 34, 18}, // X
|
|
{234, 34, 18}, // Y
|
|
{5, 64, 14}, // Z
|
|
{153, 152, 13}, // {
|
|
{11, 181, 5}, // |
|
|
{180, 152, 13}, // }
|
|
{79, 93, 17}, // ~
|
|
{0, 0, -1} // DEL
|
|
};*/
|
|
|
|
static int propMapB[26][3] = {
|
|
{11, 12, 33},
|
|
{49, 12, 31},
|
|
{85, 12, 31},
|
|
{120, 12, 30},
|
|
{156, 12, 21},
|
|
{183, 12, 21},
|
|
{207, 12, 32},
|
|
|
|
{13, 55, 30},
|
|
{49, 55, 13},
|
|
{66, 55, 29},
|
|
{101, 55, 31},
|
|
{135, 55, 21},
|
|
{158, 55, 40},
|
|
{204, 55, 32},
|
|
|
|
{12, 97, 31},
|
|
{48, 97, 31},
|
|
{82, 97, 30},
|
|
{118, 97, 30},
|
|
{153, 97, 30},
|
|
{185, 97, 25},
|
|
{213, 97, 30},
|
|
|
|
{11, 139, 32},
|
|
{42, 139, 51},
|
|
{93, 139, 32},
|
|
{126, 139, 31},
|
|
{158, 139, 25},
|
|
};
|
|
|
|
#define PROPB_GAP_WIDTH 4
|
|
#define PROPB_SPACE_WIDTH 12
|
|
#define PROPB_HEIGHT 36
|
|
|
|
/*
|
|
=================
|
|
UI_DrawBannerString
|
|
=================
|
|
*/
|
|
static void UI_DrawBannerString2(int x, int y, const char *str, vec4_t color)
|
|
{
|
|
const char *s;
|
|
unsigned char ch; // bk001204 : array subscript
|
|
float ax;
|
|
float ay;
|
|
float aw;
|
|
float ah;
|
|
float frow;
|
|
float fcol;
|
|
float fwidth;
|
|
float fheight;
|
|
|
|
// draw the colored text
|
|
trap_R_SetColor(color);
|
|
|
|
ax = x * cgs.screenXScale + cgs.screenXBias;
|
|
ay = y * cgs.screenYScale;
|
|
|
|
s = str;
|
|
while (*s) {
|
|
ch = *s & 127;
|
|
if (ch == ' ') {
|
|
ax += ((float) PROPB_SPACE_WIDTH + (float) PROPB_GAP_WIDTH) * cgs.screenXScale;
|
|
} else if (ch >= 'A' && ch <= 'Z') {
|
|
ch -= 'A';
|
|
fcol = (float) propMapB[ch][0] / 256.0f;
|
|
frow = (float) propMapB[ch][1] / 256.0f;
|
|
fwidth = (float) propMapB[ch][2] / 256.0f;
|
|
fheight = (float) PROPB_HEIGHT / 256.0f;
|
|
aw = (float) propMapB[ch][2] * cgs.screenXScale;
|
|
ah = (float) PROPB_HEIGHT *cgs.screenYScale;
|
|
|
|
trap_R_DrawStretchPic(ax, ay, aw, ah, fcol, frow, fcol + fwidth, frow + fheight,
|
|
cgs.media.charsetPropB);
|
|
ax += (aw + (float) PROPB_GAP_WIDTH * cgs.screenXScale);
|
|
}
|
|
s++;
|
|
}
|
|
|
|
trap_R_SetColor(NULL);
|
|
}
|
|
|
|
void UI_DrawBannerString(int x, int y, const char *str, int style, vec4_t color)
|
|
{
|
|
const char *s;
|
|
int ch;
|
|
int width;
|
|
vec4_t drawcolor;
|
|
|
|
// find the width of the drawn text
|
|
s = str;
|
|
width = 0;
|
|
while (*s) {
|
|
ch = *s;
|
|
if (ch == ' ') {
|
|
width += PROPB_SPACE_WIDTH;
|
|
} else if (ch >= 'A' && ch <= 'Z') {
|
|
width += propMapB[ch - 'A'][2] + PROPB_GAP_WIDTH;
|
|
}
|
|
s++;
|
|
}
|
|
width -= PROPB_GAP_WIDTH;
|
|
|
|
switch (style & UI_FORMATMASK) {
|
|
case UI_CENTER:
|
|
x -= width / 2;
|
|
break;
|
|
|
|
case UI_RIGHT:
|
|
x -= width;
|
|
break;
|
|
|
|
case UI_LEFT:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (style & UI_DROPSHADOW) {
|
|
drawcolor[0] = drawcolor[1] = drawcolor[2] = 0;
|
|
drawcolor[3] = color[3];
|
|
UI_DrawBannerString2(x + 2, y + 2, str, drawcolor);
|
|
}
|
|
|
|
UI_DrawBannerString2(x, y, str, color);
|
|
}
|
|
|
|
int UI_ProportionalStringWidth(const char *str)
|
|
{
|
|
const char *s;
|
|
int ch;
|
|
int charWidth;
|
|
int width;
|
|
|
|
s = str;
|
|
width = 0;
|
|
while (*s) {
|
|
ch = *s & 127;
|
|
charWidth = propMap[ch][2];
|
|
if (charWidth != -1) {
|
|
width += charWidth;
|
|
width += PROP_GAP_WIDTH;
|
|
}
|
|
s++;
|
|
}
|
|
|
|
width -= PROP_GAP_WIDTH;
|
|
return width;
|
|
}
|
|
|
|
static void UI_DrawProportionalString2(int x, int y, const char *str, vec4_t color, float sizeScale, qhandle_t charset)
|
|
{
|
|
const char *s;
|
|
unsigned char ch; // bk001204 - unsigned
|
|
float ax;
|
|
float ay;
|
|
float aw;
|
|
float ah;
|
|
float frow;
|
|
float fcol;
|
|
float fwidth;
|
|
float fheight;
|
|
|
|
// draw the colored text
|
|
trap_R_SetColor(color);
|
|
|
|
ax = x * cgs.screenXScale + cgs.screenXBias;
|
|
// Elder: typo in the mod source
|
|
//ay = y * cgs.screenXScale;
|
|
ay = y * cgs.screenYScale;
|
|
|
|
s = str;
|
|
while (*s) {
|
|
ch = *s & 127;
|
|
if (ch == ' ') {
|
|
aw = (float) PROP_SPACE_WIDTH *cgs.screenXScale * sizeScale;
|
|
} else if (propMap[ch][2] != -1) {
|
|
fcol = (float) propMap[ch][0] / 512.0f;
|
|
frow = (float) propMap[ch][1] / 256.0f;
|
|
fwidth = (float) propMap[ch][2] / 512.0f;
|
|
fheight = (float) PROP_HEIGHT / 256.0f;
|
|
aw = (float) propMap[ch][2] * cgs.screenXScale * sizeScale;
|
|
ah = (float) PROP_HEIGHT *cgs.screenXScale * sizeScale;
|
|
|
|
trap_R_DrawStretchPic(ax, ay, aw, ah, fcol, frow, fcol + fwidth, frow + fheight, charset);
|
|
} else {
|
|
aw = 0;
|
|
}
|
|
|
|
ax += (aw + (float) PROP_GAP_WIDTH * cgs.screenXScale * sizeScale);
|
|
s++;
|
|
}
|
|
|
|
trap_R_SetColor(NULL);
|
|
}
|
|
|
|
/*
|
|
=================
|
|
UI_ProportionalSizeScale
|
|
=================
|
|
*/
|
|
float UI_ProportionalSizeScale(int style)
|
|
{
|
|
if (style & UI_SMALLFONT) {
|
|
return 0.75;
|
|
}
|
|
|
|
//return 1.00;
|
|
//TTI: HUD font upgrade
|
|
return 0.4f;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
UI_DrawProportionalString
|
|
=================
|
|
*/
|
|
void UI_DrawProportionalString(int x, int y, const char *str, int style, vec4_t color)
|
|
{
|
|
vec4_t drawcolor;
|
|
int width;
|
|
float sizeScale;
|
|
|
|
sizeScale = UI_ProportionalSizeScale(style);
|
|
|
|
switch (style & UI_FORMATMASK) {
|
|
case UI_CENTER:
|
|
width = UI_ProportionalStringWidth(str) * sizeScale;
|
|
x -= width / 2;
|
|
break;
|
|
|
|
case UI_RIGHT:
|
|
width = UI_ProportionalStringWidth(str) * sizeScale;
|
|
x -= width;
|
|
break;
|
|
|
|
case UI_LEFT:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (style & UI_DROPSHADOW) {
|
|
drawcolor[0] = drawcolor[1] = drawcolor[2] = 0;
|
|
drawcolor[3] = color[3];
|
|
UI_DrawProportionalString2(x + 2, y + 2, str, drawcolor, sizeScale, cgs.media.charsetProp);
|
|
}
|
|
|
|
if (style & UI_INVERSE) {
|
|
drawcolor[0] = color[0] * 0.8;
|
|
drawcolor[1] = color[1] * 0.8;
|
|
drawcolor[2] = color[2] * 0.8;
|
|
drawcolor[3] = color[3];
|
|
UI_DrawProportionalString2(x, y, str, drawcolor, sizeScale, cgs.media.charsetProp);
|
|
return;
|
|
}
|
|
|
|
if (style & UI_PULSE) {
|
|
drawcolor[0] = color[0] * 0.8;
|
|
drawcolor[1] = color[1] * 0.8;
|
|
drawcolor[2] = color[2] * 0.8;
|
|
drawcolor[3] = color[3];
|
|
UI_DrawProportionalString2(x, y, str, color, sizeScale, cgs.media.charsetProp);
|
|
|
|
drawcolor[0] = color[0];
|
|
drawcolor[1] = color[1];
|
|
drawcolor[2] = color[2];
|
|
drawcolor[3] = 0.5 + 0.5 * sin(cg.time / PULSE_DIVISOR);
|
|
UI_DrawProportionalString2(x, y, str, drawcolor, sizeScale, cgs.media.charsetPropGlow);
|
|
return;
|
|
}
|
|
|
|
UI_DrawProportionalString2(x, y, str, color, sizeScale, cgs.media.charsetProp);
|
|
}
|