mirror of
https://github.com/UberGames/rpgxEF.git
synced 2025-02-23 12:31:15 +00:00
9cac290629
- Fixed all errors that occured due to using c++ compiler - changed c++ standart to c++17 - removed lua, added library instead - made all bg_* and q_* file into a shared item project
1878 lines
46 KiB
C++
1878 lines
46 KiB
C++
// 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"
|
|
|
|
enum cg_drawtoolsLimits_e {
|
|
CHARMAX = 256
|
|
};
|
|
|
|
static qboolean CG_IsWidescreen(void)
|
|
{
|
|
if (cg_handleWidescreen.integer && cgs.widescreen.ratio && cgs.widescreen.state != WIDESCREEN_NONE)
|
|
return qtrue;
|
|
|
|
return qfalse;
|
|
}
|
|
|
|
/*
|
|
================
|
|
CG_AdjustFrom640
|
|
|
|
Adjusted for resolution and screen aspect ratio
|
|
================
|
|
*/
|
|
void CG_AdjustFrom640(float *x, float *y, float *w, float *h) {
|
|
//TiM - huh.... looks like the were looking into widescreens.
|
|
//only offsetting the X value isn't good enough tho
|
|
#if 0
|
|
// adjust for wide screens
|
|
if ( cgs.glconfig.vidWidth * 480 > cgs.glconfig.vidHeight * 640 ) {
|
|
*x += 0.5 * ( cgs.glconfig.vidWidth - ( cgs.glconfig.vidHeight * 640 / 480 ) );
|
|
}
|
|
#endif
|
|
// scale for screen sizes
|
|
*x *= cgs.screenXScale;
|
|
*y *= cgs.screenYScale;
|
|
*w *= cgs.screenXScale;
|
|
*h *= cgs.screenYScale;
|
|
|
|
//TiM - handle widescreens
|
|
if (CG_IsWidescreen())
|
|
{
|
|
*w *= cgs.widescreen.ratio;
|
|
|
|
if (cgs.widescreen.state == WIDESCREEN_RIGHT)
|
|
*x = (*x * cgs.widescreen.ratio) + (cgs.widescreen.bias * 2);//*x = (*x+*w) - (*w * cgs.widescreen.ratio);
|
|
else if (cgs.widescreen.state == WIDESCREEN_CENTER)
|
|
*x = (*x * cgs.widescreen.ratio) + (cgs.widescreen.bias);
|
|
else
|
|
*x *= cgs.widescreen.ratio;
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
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_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_DrawStretchPic
|
|
|
|
TiM: Made so we can use
|
|
s1 - t2 as parameters as well :)
|
|
|
|
Coordinates are 640*480 virtual values
|
|
=================
|
|
*/
|
|
void CG_DrawStretchPic(float x, float y, float width, float height, float s1, float t1, float s2, float t2, qhandle_t hShader) {
|
|
CG_AdjustFrom640(&x, &y, &width, &height);
|
|
trap_R_DrawStretchPic(x, y, width, height, s1, t1, s2, t2, hShader);
|
|
}
|
|
|
|
/*
|
|
===============
|
|
CG_DrawChar
|
|
|
|
Coordinates and size in 640*480 virtual screen size
|
|
===============
|
|
*/
|
|
void CG_DrawChar(int32_t x, int32_t y, int32_t width, int32_t height, int32_t ch) {
|
|
int32_t row, col;
|
|
float frow, fcol;
|
|
float size, size2;
|
|
float ax, ay, aw, ah;
|
|
|
|
ch &= 255;
|
|
|
|
if (ch == ' ') {
|
|
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.03125;
|
|
size2 = 0.0625;
|
|
|
|
trap_R_DrawStretchPic(ax, ay, aw, ah,
|
|
fcol, frow,
|
|
fcol + size, frow + size2,
|
|
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(int32_t x, int32_t y, const char *string, const float *setColor,
|
|
qboolean forceColor, qboolean shadow, int32_t charWidth, int32_t charHeight, int32_t maxChars) {
|
|
vec4_t color;
|
|
const char *s;
|
|
int32_t xx;
|
|
int32_t 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;
|
|
}
|
|
CG_DrawChar(xx + 2, y + 2, 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) {
|
|
memcpy(color, g_color_table[ColorIndex(*(s + 1))], sizeof(color));
|
|
color[3] = setColor[3];
|
|
trap_R_SetColor(color);
|
|
}
|
|
s += 2;
|
|
continue;
|
|
}
|
|
CG_DrawChar(xx, y, charWidth, charHeight, *s);
|
|
xx += charWidth;
|
|
cnt++;
|
|
s++;
|
|
}
|
|
trap_R_SetColor(NULL);
|
|
}
|
|
|
|
void CG_DrawBigString(int32_t x, int32_t 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(int32_t x, int32_t y, const char *s, vec4_t color) {
|
|
CG_DrawStringExt(x, y, s, color, qtrue, qtrue, BIGCHAR_WIDTH, BIGCHAR_HEIGHT, 0);
|
|
}
|
|
|
|
void CG_DrawSmallString(int32_t x, int32_t 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(int32_t x, int32_t 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
|
|
=================
|
|
*/
|
|
int32_t CG_DrawStrlen(const char *str) {
|
|
const char *s = str;
|
|
int32_t count = 0;
|
|
|
|
while (*s) {
|
|
if (Q_IsColorString(s)) {
|
|
s += 2;
|
|
}
|
|
else {
|
|
count++;
|
|
s++;
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
CG_TileClearBox
|
|
|
|
This repeats a 64*64 tile graphic to fill the screen around a sized down
|
|
refresh window.
|
|
=============
|
|
*/
|
|
static void CG_TileClearBox(int32_t x, int32_t y, int32_t w, int32_t h, qhandle_t hShader) {
|
|
float s1, t1, s2, t2;
|
|
|
|
s1 = x / 64;
|
|
t1 = y / 64;
|
|
s2 = (x + w) / 64;
|
|
t2 = (y + h) / 64;
|
|
trap_R_DrawStretchPic(x, y, w, h, s1, t1, s2, t2, hShader);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
==============
|
|
CG_TileClear
|
|
|
|
Clear around a sized down screen
|
|
==============
|
|
*/
|
|
void CG_TileClear(void) {
|
|
int32_t top, bottom, left, right;
|
|
int32_t 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(int32_t startMsec, int32_t totalMsec) {
|
|
static vec4_t color;
|
|
int32_t 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
|
|
================
|
|
*/
|
|
float *CG_TeamColor(int32_t team) {
|
|
static vec4_t red = { 1, 0.2, 0.2, 1 };
|
|
static vec4_t blue = { 0.2, 0.2, 1, 1 };
|
|
static vec4_t other = { 1, 1, 1, 1 };
|
|
static vec4_t spectator = { 0.7, 0.7, 0.7, 1 };
|
|
|
|
switch (team) {
|
|
case TEAM_RED:
|
|
return red;
|
|
case TEAM_BLUE:
|
|
return blue;
|
|
case TEAM_SPECTATOR:
|
|
return spectator;
|
|
default:
|
|
return other;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
=================
|
|
CG_GetColorForHealth
|
|
=================
|
|
*/
|
|
void CG_GetColorForHealth(int32_t health, int32_t armor, vec4_t hcolor) {
|
|
int32_t count;
|
|
int32_t 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;
|
|
// kef -- FIXME ...not sure what's happening here, but a divide-by-zero would be bad
|
|
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);
|
|
}
|
|
|
|
|
|
static int32_t propMapTiny[CHARMAX][3];
|
|
static int32_t propMap[CHARMAX][3];
|
|
static int32_t propMapBig[CHARMAX][3];
|
|
|
|
static int32_t 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 },
|
|
};
|
|
|
|
static const uint32_t PROPB_GAP_WIDTH = 4;
|
|
static const uint32_t PROPB_SPACE_WIDTH = 12;
|
|
static const uint32_t PROPB_HEIGHT = 36;
|
|
|
|
static const uint32_t TEXTSHEET_SIZE = 512; //TiM
|
|
#define ORIG_SCALE TEXTSHEET_SIZE / 256
|
|
|
|
/*
|
|
=================
|
|
UI_DrawBannerString
|
|
=================
|
|
*/
|
|
static void UI_DrawBannerString2(int32_t x, int32_t y, const char* str, vec4_t color)
|
|
{
|
|
const char* s;
|
|
char ch;
|
|
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;
|
|
ax = x * cgs.screenXScale;
|
|
ay = y * cgs.screenYScale;
|
|
|
|
s = str;
|
|
while (*s)
|
|
{
|
|
ch = *s & 255;
|
|
if (ch == ' ') {
|
|
ax += ((float)PROPB_SPACE_WIDTH + (float)PROPB_GAP_WIDTH)* cgs.screenXScale;
|
|
}
|
|
else if (ch >= 'A' && ch <= 'Z') {
|
|
ch -= 'A';
|
|
fcol = (float)propMapB[(int32_t)ch][0] / 256;
|
|
frow = (float)propMapB[(int32_t)ch][1] / 256;
|
|
fwidth = (float)propMapB[(int32_t)ch][2] / 256;
|
|
fheight = (float)PROPB_HEIGHT / 256;
|
|
aw = (float)(propMapB[(int32_t)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(int32_t x, int32_t y, const char* str, int32_t style, vec4_t color) {
|
|
const char * s;
|
|
int32_t ch;
|
|
int32_t 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);
|
|
}
|
|
|
|
#define MAX_STRINGWIDTH 2048
|
|
|
|
/*
|
|
=================
|
|
UI_ProportionalSizeScale
|
|
=================
|
|
*/
|
|
int32_t UI_ProportionalStringWidth(const char* str, int32_t style)
|
|
{
|
|
const char * s;
|
|
int32_t ch;
|
|
int32_t charWidth;
|
|
int32_t width;
|
|
char holdStr[2048];
|
|
|
|
Q_strncpyz(holdStr, str, MAX_STRINGWIDTH);
|
|
|
|
Q_CleanStr(holdStr);
|
|
|
|
if (style & UI_TINYFONT)
|
|
{
|
|
s = holdStr;
|
|
width = 0;
|
|
while (*s)
|
|
{
|
|
ch = *s & 255;
|
|
charWidth = propMapTiny[ch][2];
|
|
if (charWidth != -1)
|
|
{
|
|
width += charWidth;
|
|
width += PROP_GAP_TINY_WIDTH;
|
|
}
|
|
s++;
|
|
}
|
|
|
|
width -= PROP_GAP_TINY_WIDTH;
|
|
}
|
|
else if (style & UI_BIGFONT)
|
|
{
|
|
s = holdStr;
|
|
width = 0;
|
|
while (*s)
|
|
{
|
|
ch = *s & 255;
|
|
charWidth = propMapBig[ch][2];
|
|
if (charWidth != -1)
|
|
{
|
|
width += charWidth;
|
|
width += PROP_GAP_BIG_WIDTH;
|
|
}
|
|
s++;
|
|
}
|
|
|
|
width -= PROP_GAP_BIG_WIDTH;
|
|
}
|
|
else
|
|
{
|
|
s = holdStr;
|
|
width = 0;
|
|
while (*s)
|
|
{
|
|
ch = *s & 255;
|
|
charWidth = propMap[ch][2];
|
|
if (charWidth != -1)
|
|
{
|
|
width += charWidth;
|
|
width += PROP_GAP_WIDTH;
|
|
}
|
|
s++;
|
|
}
|
|
|
|
width -= PROP_GAP_WIDTH;
|
|
}
|
|
|
|
return width;
|
|
}
|
|
|
|
static int32_t specialTinyPropChars[CHARMAX][2] = {
|
|
{ 0, 0 },
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 10
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 20
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 30
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 40
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 50
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 60
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 70
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 80
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 90
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 100
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 110
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 120
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 130
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 140
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 150
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 2, -3 }, { 0, 0 }, // 160
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 170
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 180
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 190
|
|
{ 0, -1 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 0, 0 }, { 2, 0 }, { 2, -3 }, // 200
|
|
{ 2, -3 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 0, -1 }, { 2, -3 }, { 2, -3 }, // 210
|
|
{ 2, -3 }, { 3, -3 }, { 2, -3 }, { 2, -3 }, { 0, 0 }, { 0, -1 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, // 220
|
|
{ 2, -3 }, { 0, -1 }, { 0, -1 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 0, 0 }, // 230
|
|
{ 2, 0 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 0, 0 }, // 240
|
|
{ 2, -3 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 2, -3 }, { 0, 0 }, { 0, -1 }, { 2, -3 }, { 2, -3 }, // 250
|
|
{ 2, -3 }, { 2, -3 }, { 2, -3 }, { 0, -1 }, { 2, -3 } // 255
|
|
};
|
|
|
|
|
|
static int32_t specialPropChars[CHARMAX][2] = {
|
|
{ 0, 0 },
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 10
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 20
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 30
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 40
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 50
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 60
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 70
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 80
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 90
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 100
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 110
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 120
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 130
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 140
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 150
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 160
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 170
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 180
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 190
|
|
{ 2, -2 }, { 2, -2 }, { 2, -2 }, { 2, -2 }, { 2, -2 }, { 2, -2 }, { 2, -2 }, { 0, 0 }, { 1, 1 }, { 2, -2 }, // 200
|
|
{ 2, -2 }, { 2, -2 }, { 2, -2 }, { 2, -2 }, { 2, -2 }, { 2, -2 }, { 2, -2 }, { 0, 0 }, { 2, -2 }, { 2, -2 }, // 210
|
|
{ 2, -2 }, { 2, -2 }, { 2, -2 }, { 2, -2 }, { 0, 0 }, { 0, 0 }, { 2, -2 }, { 2, -2 }, { 2, -2 }, { 2, -2 }, // 220
|
|
{ 2, -2 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 230
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 240
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 250
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } // 255
|
|
};
|
|
|
|
|
|
static int32_t specialBigPropChars[CHARMAX][2] = {
|
|
{ 0, 0 },
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 10
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 20
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 30
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 40
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 50
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 60
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 70
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 80
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 90
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 100
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 110
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 120
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 130
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 140
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 150
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 160
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 170
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 180
|
|
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, // 190
|
|
{ 3, -3 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 0, 0 }, { 3, 1 }, { 3, -3 }, // 200
|
|
{ 3, -3 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 0, 0 }, { 3, -3 }, { 3, -3 }, // 210
|
|
{ 3, -3 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 0, 0 }, { 0, 0 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, // 220
|
|
{ 3, -3 }, { 0, 0 }, { 0, 0 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 0, 0 }, // 230
|
|
{ 3, 1 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 0, 0 }, // 240
|
|
{ 3, -3 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 3, -3 }, { 0, 0 }, { 0, 0 }, { 3, -3 }, { 3, -3 }, // 250
|
|
{ 3, -3 }, { 3, -3 }, { 3, -3 }, { 0, 0 }, { 3, -3 } // 255
|
|
};
|
|
|
|
/*
|
|
=================
|
|
UI_AdjustForWideScreen
|
|
=================
|
|
*/
|
|
static void UI_AdjustForWidescreen(float *x, float *w)
|
|
{
|
|
if (CG_IsWidescreen())
|
|
*w *= cgs.widescreen.ratio;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
UI_DrawProportionalString2
|
|
=================
|
|
*/
|
|
static void UI_DrawProportionalString2(int32_t x, int32_t y, const char* str, vec4_t color, float sizeScale, int32_t style, qhandle_t charset, qboolean forceColor)
|
|
{
|
|
const char* s;
|
|
unsigned char ch;
|
|
float ax;
|
|
float ay, holdY;
|
|
float aw = 0; // stop compiler complaining about uninitialised vars
|
|
float ah;
|
|
float frow;
|
|
float fcol;
|
|
float fwidth;
|
|
float fheight;
|
|
int32_t colorI;
|
|
int32_t special;
|
|
|
|
// draw the colored text
|
|
trap_R_SetColor(color);
|
|
|
|
// ax = x * cgs.screenXScale + cgs.screenXBias;
|
|
ax = x * cgs.screenXScale;
|
|
ay = y * cgs.screenYScale;
|
|
holdY = ay;
|
|
|
|
if (CG_IsWidescreen())
|
|
{
|
|
ax *= cgs.widescreen.ratio;
|
|
|
|
if (cgs.widescreen.state == WIDESCREEN_CENTER)
|
|
ax += cgs.widescreen.bias;
|
|
else if (cgs.widescreen.state == WIDESCREEN_RIGHT)
|
|
ax += (cgs.widescreen.bias * 2);
|
|
}
|
|
|
|
if (style & UI_TINYFONT)
|
|
{
|
|
s = str;
|
|
while (*s)
|
|
{
|
|
// Is there a color character
|
|
if (Q_IsColorString(s))
|
|
{
|
|
if (!forceColor)
|
|
{
|
|
colorI = ColorIndex(*(s + 1));
|
|
trap_R_SetColor(g_color_table[colorI]);
|
|
}
|
|
s += 2;
|
|
continue;
|
|
}
|
|
|
|
//CG_Printf("s = %s, ch = %s", s, ch);
|
|
|
|
ch = *s & 255;
|
|
if (ch == ' ')
|
|
{
|
|
aw = (float)PROP_SPACE_TINY_WIDTH;
|
|
}
|
|
else if (propMapTiny[ch][2] != -1)
|
|
{
|
|
// Because some foreign characters were a little different
|
|
special = specialTinyPropChars[ch][0];
|
|
ay = holdY + (specialTinyPropChars[ch][1] * cgs.screenYScale);
|
|
|
|
fcol = (float)propMapTiny[ch][0] / 256;
|
|
frow = (float)propMapTiny[ch][1] / 256;
|
|
fwidth = (float)propMapTiny[ch][2] / 256;
|
|
fheight = (float)(PROP_TINY_HEIGHT + special) / 256;
|
|
aw = (float)propMapTiny[ch][2] * cgs.screenXScale * sizeScale;
|
|
ah = (float)(PROP_TINY_HEIGHT + special) * cgs.screenYScale * sizeScale;
|
|
|
|
//TiM - adjust for widescreen
|
|
UI_AdjustForWidescreen(&ax, &aw);
|
|
|
|
trap_R_DrawStretchPic(ax, ay, aw, ah, fcol, frow, fcol + fwidth, frow + fheight, charset);
|
|
|
|
}
|
|
|
|
ax += (aw + (float)PROP_GAP_TINY_WIDTH * cgs.screenXScale * sizeScale);
|
|
|
|
if (CG_IsWidescreen())
|
|
ax -= ((float)PROP_GAP_TINY_WIDTH * cgs.screenXScale * sizeScale)*(1.0f - cgs.widescreen.ratio);
|
|
|
|
s++;
|
|
}
|
|
}
|
|
else if (style & UI_BIGFONT)
|
|
{
|
|
s = str;
|
|
while (*s)
|
|
{
|
|
// Is there a color character
|
|
if (Q_IsColorString(s))
|
|
{
|
|
if (!forceColor)
|
|
{
|
|
colorI = ColorIndex(*(s + 1));
|
|
trap_R_SetColor(g_color_table[colorI]);
|
|
}
|
|
s += 2;
|
|
continue;
|
|
}
|
|
|
|
ch = *s & 255;
|
|
if (ch == ' ')
|
|
{
|
|
aw = (float)PROP_SPACE_BIG_WIDTH* cgs.screenXScale * sizeScale;
|
|
}
|
|
else if (propMap[ch][2] != -1)
|
|
{
|
|
// Because some foreign characters were a little different
|
|
special = specialBigPropChars[ch][0];
|
|
ay = holdY + (specialBigPropChars[ch][1] * cgs.screenYScale);
|
|
|
|
fcol = (float)propMapBig[ch][0] / 256; //256.0f
|
|
frow = (float)propMapBig[ch][1] / 256;
|
|
fwidth = (float)propMapBig[ch][2] / 256;
|
|
fheight = (float)(PROP_BIG_HEIGHT + special) / 256;
|
|
aw = (float)propMapBig[ch][2] * cgs.screenXScale * sizeScale;
|
|
ah = (float)(PROP_BIG_HEIGHT + special) * cgs.screenYScale * sizeScale;
|
|
|
|
//TiM - adjust for widescreen
|
|
UI_AdjustForWidescreen(&ax, &aw);
|
|
|
|
trap_R_DrawStretchPic(ax, ay, aw, ah, fcol, frow, fcol + fwidth, frow + fheight,
|
|
charset);
|
|
|
|
}
|
|
else
|
|
{
|
|
aw = 0;
|
|
}
|
|
|
|
ax += (aw + (float)PROP_GAP_BIG_WIDTH * cgs.screenXScale * sizeScale);
|
|
|
|
if (CG_IsWidescreen())
|
|
ax -= ((float)PROP_GAP_BIG_WIDTH * cgs.screenXScale * sizeScale)*(1.0f - cgs.widescreen.ratio);
|
|
|
|
|
|
s++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
s = str;
|
|
while (*s)
|
|
{
|
|
// Is there a color character
|
|
if (Q_IsColorString(s))
|
|
{
|
|
if (!forceColor)
|
|
{
|
|
colorI = ColorIndex(*(s + 1));
|
|
trap_R_SetColor(g_color_table[colorI]);
|
|
}
|
|
s += 2;
|
|
continue;
|
|
}
|
|
|
|
ch = *s & 255;
|
|
if (ch == ' ')
|
|
{
|
|
aw = (float)PROP_SPACE_WIDTH * cgs.screenXScale * sizeScale;
|
|
}
|
|
else if (propMap[ch][2] != -1)
|
|
{
|
|
// Because some foreign characters were a little different
|
|
special = specialPropChars[ch][0];
|
|
ay = holdY + (specialPropChars[ch][1] * cgs.screenYScale);
|
|
|
|
fcol = (float)propMap[ch][0] / 256;
|
|
frow = (float)propMap[ch][1] / 256;
|
|
fwidth = (float)propMap[ch][2] / 256;
|
|
fheight = (float)(PROP_HEIGHT + special) / 256;
|
|
aw = (float)(propMap[ch][2] * cgs.screenXScale * sizeScale);
|
|
ah = (float)((PROP_HEIGHT + special) * cgs.screenYScale * sizeScale);
|
|
|
|
//TiM - adjust for widescreen
|
|
UI_AdjustForWidescreen(&ax, &aw);
|
|
|
|
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);
|
|
|
|
if (CG_IsWidescreen())
|
|
ax -= ((float)PROP_GAP_WIDTH * cgs.screenXScale * sizeScale)*(1.0f - cgs.widescreen.ratio);
|
|
|
|
s++;
|
|
}
|
|
}
|
|
trap_R_SetColor(NULL);
|
|
}
|
|
|
|
/*
|
|
=================
|
|
UI_ProportionalSizeScale
|
|
=================
|
|
*/
|
|
float UI_ProportionalSizeScale(int32_t style)
|
|
{
|
|
if (style & UI_SMALLFONT)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
return 1.00;
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
UI_DrawProportionalString
|
|
=================
|
|
*/
|
|
void UI_DrawProportionalString(int32_t x, int32_t y, const char* str, int32_t style, vec4_t color)
|
|
{
|
|
vec4_t drawcolor;
|
|
int32_t width;
|
|
float sizeScale;
|
|
qhandle_t charset;
|
|
|
|
sizeScale = UI_ProportionalSizeScale(style);
|
|
|
|
switch (style & UI_FORMATMASK)
|
|
{
|
|
case UI_CENTER:
|
|
width = UI_ProportionalStringWidth(str, style) * sizeScale;
|
|
x -= width / 2;
|
|
break;
|
|
|
|
case UI_RIGHT:
|
|
width = UI_ProportionalStringWidth(str, style) * sizeScale;
|
|
x -= width;
|
|
break;
|
|
|
|
case UI_LEFT:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
//TiM - vertical align
|
|
if (style & UI_BOTTOM)
|
|
{
|
|
if (style & UI_TINYFONT)
|
|
y -= (PROP_TINY_HEIGHT + 3);
|
|
else if (style & UI_BIGFONT)
|
|
y -= (PROP_BIG_HEIGHT + 3);
|
|
else
|
|
y -= (PROP_HEIGHT + 3);
|
|
}
|
|
|
|
if (style & UI_TINYFONT)
|
|
{
|
|
charset = cgs.media.charsetPropTiny;
|
|
}
|
|
else if (style & UI_BIGFONT)
|
|
{
|
|
charset = cgs.media.charsetPropBig;
|
|
sizeScale = 1;
|
|
}
|
|
else
|
|
{
|
|
charset = cgs.media.charsetProp;
|
|
sizeScale = 1;
|
|
}
|
|
|
|
if (style & UI_DROPSHADOW)
|
|
{
|
|
drawcolor[0] = drawcolor[1] = drawcolor[2] = 0;
|
|
drawcolor[3] = color[3];
|
|
|
|
UI_DrawProportionalString2(x + 2, y + 2, str, drawcolor, sizeScale, style, charset, qtrue);
|
|
}
|
|
|
|
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, style, charset, qtrue);
|
|
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, style, charset, qtrue);
|
|
|
|
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, style, charset, qtrue);
|
|
return;
|
|
}
|
|
|
|
if (style & UI_FORCECOLOR)
|
|
{
|
|
UI_DrawProportionalString2(x, y, str, color, sizeScale, style, charset, qtrue);
|
|
return;
|
|
}
|
|
|
|
UI_DrawProportionalString2(x, y, str, color, sizeScale, style, charset, qfalse);
|
|
}
|
|
|
|
/*
|
|
==============
|
|
CG_DrawNumField
|
|
|
|
Take x,y positions as if 640 x 480 and scales them to the proper resolution
|
|
|
|
==============
|
|
*/
|
|
void CG_DrawNumField(int32_t x, int32_t y, int32_t width, int32_t value, int32_t charWidth, int32_t charHeight, int32_t style)
|
|
{
|
|
char num[16], *ptr;
|
|
int32_t l;
|
|
int32_t frame;
|
|
int32_t xWidth;
|
|
|
|
if (width < 1) {
|
|
return;
|
|
}
|
|
|
|
// draw number string
|
|
if (width > 5) {
|
|
width = 5;
|
|
}
|
|
|
|
switch (width) {
|
|
case 1:
|
|
value = value > 9 ? 9 : value;
|
|
value = value < 0 ? 0 : value;
|
|
break;
|
|
case 2:
|
|
value = value > 99 ? 99 : value;
|
|
value = value < -9 ? -9 : value;
|
|
break;
|
|
case 3:
|
|
value = value > 999 ? 999 : value;
|
|
value = value < -99 ? -99 : value;
|
|
break;
|
|
case 4:
|
|
value = value > 9999 ? 9999 : value;
|
|
value = value < -999 ? -999 : value;
|
|
break;
|
|
}
|
|
|
|
Com_sprintf(num, sizeof(num), "%i", value);
|
|
l = strlen(num);
|
|
if (l > width)
|
|
l = width;
|
|
|
|
if (style & NUM_FONT_SMALL)
|
|
{
|
|
xWidth = 4 + 2;
|
|
}
|
|
else
|
|
{
|
|
xWidth = (charWidth / 2) + 3;//(charWidth/6);
|
|
}
|
|
|
|
x += 2 + (xWidth)*(width - l);
|
|
|
|
ptr = num;
|
|
while (*ptr && l)
|
|
{
|
|
if (*ptr == '-')
|
|
frame = STAT_MINUS;
|
|
else
|
|
frame = *ptr - '0';
|
|
|
|
if (style & NUM_FONT_SMALL)
|
|
{
|
|
CG_DrawPic(x, y, charWidth, charHeight, cgs.media.smallnumberShaders[frame]);
|
|
}
|
|
else
|
|
{
|
|
CG_DrawPic(x, y, charWidth, charHeight, cgs.media.numberShaders[frame]);
|
|
}
|
|
|
|
x += (xWidth);
|
|
ptr++;
|
|
l--;
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
================
|
|
CG_PrintInterfaceGraphics
|
|
================
|
|
*/
|
|
void CG_PrintInterfaceGraphics(int32_t min, int32_t max)
|
|
{
|
|
int32_t i;
|
|
vec4_t drawcolor;
|
|
|
|
// Printing graphics
|
|
for (i = min; i < max; ++i)
|
|
{
|
|
drawcolor[0] = colorTable[interface_graphics[i].color][0];
|
|
drawcolor[1] = colorTable[interface_graphics[i].color][1];
|
|
drawcolor[2] = colorTable[interface_graphics[i].color][2];
|
|
drawcolor[3] = colorTable[interface_graphics[i].color][3];
|
|
|
|
if (cg.snap->ps.persistant[PERS_TEAM] == TEAM_RED)
|
|
{
|
|
drawcolor[0] = 1;
|
|
}
|
|
else if (cg.snap->ps.persistant[PERS_TEAM] == TEAM_BLUE)
|
|
{
|
|
drawcolor[2] = 1;
|
|
}
|
|
|
|
if (interface_graphics[i].type == SG_GRAPHIC)
|
|
{
|
|
trap_R_SetColor(drawcolor);
|
|
|
|
CG_DrawPic(interface_graphics[i].x,
|
|
interface_graphics[i].y,
|
|
interface_graphics[i].width,
|
|
interface_graphics[i].height,
|
|
interface_graphics[i].graphic);
|
|
}
|
|
else if (interface_graphics[i].type == SG_NUMBER)
|
|
{
|
|
if (interface_graphics[i].style & UI_PULSE)
|
|
{
|
|
drawcolor[3] = 0.5 + 0.5*sin(cg.time / PULSE_DIVISOR);
|
|
}
|
|
trap_R_SetColor(drawcolor);
|
|
|
|
CG_DrawNumField(
|
|
interface_graphics[i].x,
|
|
interface_graphics[i].y, 3,
|
|
interface_graphics[i].max,
|
|
interface_graphics[i].width,
|
|
interface_graphics[i].height, interface_graphics[i].style);
|
|
}
|
|
}
|
|
|
|
trap_R_SetColor(NULL);
|
|
}
|
|
|
|
/*
|
|
=================
|
|
CG_ParseFontParms
|
|
=================
|
|
*/
|
|
static char *CG_ParseFontParms(char *buffer, int32_t propArray[CHARMAX][3])
|
|
{
|
|
char *token;
|
|
int32_t i, i2;
|
|
|
|
while (buffer)
|
|
{
|
|
token = COM_ParseExt(&buffer, qtrue);
|
|
|
|
// Start with open braket
|
|
if (!Q_stricmp(token, "{"))
|
|
{
|
|
for (i = 0; i < CHARMAX; ++i)
|
|
{
|
|
// Brackets for the numbers
|
|
token = COM_ParseExt(&buffer, qtrue);
|
|
if (!Q_stricmpn(token, "{", 1))
|
|
{
|
|
;
|
|
}
|
|
else
|
|
{
|
|
trap_Print(va(S_COLOR_RED "CG_ParseFontParms : Invalid FONTS.DAT data, near character %d!\n", i));
|
|
return(NULL);
|
|
}
|
|
|
|
for (i2 = 0; i2 < 3; ++i2)
|
|
{
|
|
token = COM_ParseExt(&buffer, qtrue);
|
|
propArray[i][i2] = atoi(token);
|
|
}
|
|
|
|
token = COM_ParseExt(&buffer, qtrue);
|
|
if (!Q_stricmp(token, "}"))
|
|
{
|
|
;
|
|
}
|
|
else
|
|
{
|
|
trap_Print(va(S_COLOR_RED "CG_ParseFontParms : Invalid FONTS.DAT data, near character %d!\n", i));
|
|
return(NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
token = COM_ParseExt(&buffer, qtrue); // Grab closing bracket
|
|
if (!Q_stricmp(token, "}"))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
return(buffer);
|
|
}
|
|
|
|
#define FONT_BUFF_LENGTH 20000
|
|
/*
|
|
=================
|
|
CG_LoadFonts
|
|
=================
|
|
*/
|
|
void CG_LoadFonts(void)
|
|
{
|
|
char buffer[FONT_BUFF_LENGTH];
|
|
int32_t len;
|
|
fileHandle_t f;
|
|
char *holdBuf;
|
|
|
|
len = trap_FS_FOpenFile("ext_data/fonts.dat", &f, FS_READ);
|
|
|
|
if (!f)
|
|
{
|
|
trap_Print(va(S_COLOR_RED "CG_LoadFonts : FONTS.DAT file not found!\n"));
|
|
return;
|
|
}
|
|
|
|
if (len > FONT_BUFF_LENGTH)
|
|
{
|
|
trap_Print(va(S_COLOR_RED "CG_LoadFonts : FONTS.DAT file bigger than %d!\n", FONT_BUFF_LENGTH));
|
|
return;
|
|
}
|
|
|
|
// initialise the data area
|
|
memset(buffer, 0, sizeof(buffer));
|
|
|
|
trap_FS_Read(buffer, len, f);
|
|
|
|
trap_FS_FCloseFile(f);
|
|
|
|
COM_BeginParseSession();
|
|
|
|
holdBuf = (char *)buffer;
|
|
holdBuf = CG_ParseFontParms(holdBuf, propMapTiny);
|
|
holdBuf = CG_ParseFontParms(holdBuf, propMap);
|
|
holdBuf = CG_ParseFontParms(holdBuf, propMapBig);
|
|
|
|
}
|
|
|
|
/*
|
|
=================
|
|
CG_ParseRankData
|
|
|
|
Takes '{ x, y, w, h, file_route } and parses it.
|
|
=================
|
|
*/
|
|
|
|
#define MAX_RANK_WIDTH 67
|
|
#define MAX_RANK_HEIGHT 15
|
|
|
|
qboolean CG_ParseRankData(char **data, rankMenuData_t* rankMenuData) {
|
|
const char* token;
|
|
|
|
token = COM_ParseExt(data, qtrue);
|
|
if (token[0] == 0) {
|
|
Com_Printf(S_COLOR_RED "Unexpected EOF! O_o\n");
|
|
return qtrue;
|
|
}
|
|
|
|
if (!Q_stricmp(token, "{")) {
|
|
//parse w value
|
|
token = COM_ParseExt(data, qtrue);
|
|
if (token[0] == 0) {
|
|
Com_Printf(S_COLOR_RED "Unexpected EOF! O_o\n");
|
|
return qtrue;
|
|
}
|
|
rankMenuData->w = atoi(token);
|
|
|
|
if (rankMenuData->w > MAX_RANK_WIDTH) {
|
|
rankMenuData->w = MAX_RANK_WIDTH;
|
|
}
|
|
|
|
//parse h value
|
|
token = COM_ParseExt(data, qtrue);
|
|
if (token[0] == 0) {
|
|
Com_Printf(S_COLOR_RED "Unexpected EOF! O_o\n");
|
|
return qtrue;
|
|
}
|
|
rankMenuData->h = atoi(token);
|
|
|
|
if (rankMenuData->h > MAX_RANK_HEIGHT) {
|
|
rankMenuData->h = MAX_RANK_HEIGHT;
|
|
}
|
|
|
|
//parse s1 value
|
|
token = COM_ParseExt(data, qtrue);
|
|
if (token[0] == 0) {
|
|
Com_Printf(S_COLOR_RED "Unexpected EOF! O_o\n");
|
|
return qtrue;
|
|
}
|
|
rankMenuData->s1 = atoi(token);
|
|
|
|
if (!rankMenuData->s1) {
|
|
Com_Printf(S_COLOR_RED "Invalid s1 value in rankset\n");
|
|
return qtrue;
|
|
}
|
|
|
|
//parse t1 value
|
|
token = COM_ParseExt(data, qtrue);
|
|
if (token[0] == 0) {
|
|
Com_Printf(S_COLOR_RED "Unexpected EOF! O_o\n");
|
|
return qtrue;
|
|
}
|
|
rankMenuData->t1 = atoi(token);
|
|
|
|
if (!rankMenuData->t1) {
|
|
Com_Printf(S_COLOR_RED "Invalid t1 value in rankset\n");
|
|
return qtrue;
|
|
}
|
|
|
|
//parse s2 value
|
|
token = COM_ParseExt(data, qtrue);
|
|
if (token[0] == 0) {
|
|
Com_Printf(S_COLOR_RED "Unexpected EOF! O_o\n");
|
|
return qtrue;
|
|
}
|
|
rankMenuData->s2 = atoi(token);
|
|
|
|
if (!rankMenuData->s2) {
|
|
Com_Printf(S_COLOR_RED "Invalid s2 value in rankset\n");
|
|
return qtrue;
|
|
}
|
|
|
|
//parse t2 value
|
|
token = COM_ParseExt(data, qtrue);
|
|
if (token[0] == 0) {
|
|
Com_Printf(S_COLOR_RED "Unexpected EOF! O_o\n");
|
|
return qtrue;
|
|
}
|
|
rankMenuData->t2 = atoi(token);
|
|
|
|
if (!rankMenuData->t2) {
|
|
Com_Printf(S_COLOR_RED "Invalid t2 value in rankset\n");
|
|
return qtrue;
|
|
}
|
|
|
|
//parse gWidth value
|
|
token = COM_ParseExt(data, qtrue);
|
|
if (token[0] == 0) {
|
|
Com_Printf(S_COLOR_RED "Unexpected EOF! O_o\n");
|
|
return qtrue;
|
|
}
|
|
rankMenuData->gWidth = atoi(token);
|
|
|
|
if (!rankMenuData->gWidth) {
|
|
Com_Printf(S_COLOR_RED "Invalid graphic width value in rankset\n");
|
|
return qtrue;
|
|
}
|
|
|
|
//parse gHeight value
|
|
token = COM_ParseExt(data, qtrue);
|
|
if (token[0] == 0) {
|
|
Com_Printf(S_COLOR_RED "Unexpected EOF! O_o\n");
|
|
return qtrue;
|
|
}
|
|
rankMenuData->gHeight = atoi(token);
|
|
|
|
if (!rankMenuData->gHeight) {
|
|
Com_Printf(S_COLOR_RED "Invalid graphic height value in rankset\n");
|
|
return qtrue;
|
|
}
|
|
|
|
//parse graphics handle
|
|
token = COM_ParseExt(data, qtrue);
|
|
if (token[0] == 0) {
|
|
Com_Printf(S_COLOR_RED "Unexpected EOF! O_o\n");
|
|
return qtrue;
|
|
}
|
|
rankMenuData->graphic = trap_R_RegisterShaderNoMip(token);
|
|
|
|
if (!rankMenuData->graphic) {
|
|
Com_Printf(S_COLOR_RED "Unable to find shader in rankset: %s\n", token);
|
|
return qtrue;
|
|
}
|
|
|
|
//error checking - we should see a '}' now :P
|
|
token = COM_ParseExt(data, qtrue);
|
|
if (token[0] == 0) {
|
|
Com_Printf(S_COLOR_RED "Unexpected EOF! O_o\n");
|
|
return qtrue;
|
|
}
|
|
|
|
//all good :) return the function good
|
|
if (!Q_stricmp(token, "}")) {
|
|
return qfalse;
|
|
}
|
|
else {
|
|
return qtrue;
|
|
}
|
|
}
|
|
else {
|
|
Com_Printf(S_COLOR_RED "Could not find { in current rankset file.\n");
|
|
return qtrue;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=================
|
|
CG_LoadRanks
|
|
By TiM
|
|
=================
|
|
*/
|
|
qboolean CG_LoadRanks(void) {
|
|
fileHandle_t file;
|
|
int32_t file_len;
|
|
char charText[32000];
|
|
char *textPtr;
|
|
char fileName[MAX_QPATH];
|
|
int32_t i;
|
|
int32_t rankCount = 0;
|
|
char *token;
|
|
|
|
qboolean DefaultRankLoaded = qfalse;
|
|
|
|
if (cgs.rankSet) {
|
|
Com_sprintf(fileName, sizeof(fileName), "ext_data/ranksets/%s.ranks", cgs.rankSet);
|
|
}
|
|
else {
|
|
return qfalse;
|
|
}
|
|
|
|
file_len = trap_FS_FOpenFile(fileName, &file, FS_READ);
|
|
|
|
if (file == 0 || file_len <= 0) {
|
|
return qfalse;
|
|
}
|
|
|
|
if (file_len >= sizeof(charText)-1) {
|
|
Com_Printf(S_COLOR_RED "Size of rankset file %s is too large.\n", fileName);
|
|
return qfalse;
|
|
}
|
|
|
|
memset(&charText, 0, sizeof(charText));
|
|
memset(&cgs.defaultRankData, 0, sizeof(cgs.defaultRankData));
|
|
memset(&cgs.ranksData, 0, sizeof(cgs.ranksData));
|
|
|
|
trap_FS_Read(charText, file_len, file);
|
|
|
|
charText[file_len] = 0;
|
|
|
|
trap_FS_FCloseFile(file);
|
|
|
|
COM_BeginParseSession();
|
|
|
|
textPtr = charText;
|
|
|
|
token = COM_Parse(&textPtr);
|
|
|
|
if (!token[0]) {
|
|
Com_Printf(S_COLOR_RED "No data found in rankset: %s\n", fileName);
|
|
return qfalse;
|
|
}
|
|
|
|
if (Q_stricmp(token, "{")) {
|
|
Com_Printf(S_COLOR_RED "Missing starting { in rankset file: %s\n", fileName);
|
|
return qfalse;
|
|
}
|
|
|
|
//Parse the first one only... the first one should be the DEFAULT RANK!!!
|
|
//DEFAULT I SAY! IT'S SPECIAL!
|
|
//WE NEED A DEFAULT FOR ERRORS! NO DEFAULT NO RANK FOR YOU!
|
|
while (1) {
|
|
|
|
token = COM_Parse(&textPtr);
|
|
if (!token[0]) {
|
|
break;
|
|
}
|
|
|
|
if (!Q_stricmpn(token, "MenuTextureDef", 14)) {
|
|
if (CG_ParseRankData(&textPtr, &cgs.defaultRankData.rankMenuData)) {
|
|
continue;
|
|
}
|
|
|
|
DefaultRankLoaded = qtrue;
|
|
continue;
|
|
}
|
|
else if (!Q_stricmpn(token, "BoltModel", 9)) {
|
|
if (COM_ParseString(&textPtr, &token)) {
|
|
continue;
|
|
}
|
|
|
|
Q_strncpyz(cgs.defaultRankData.rankModelData.boltModelPath, token,
|
|
sizeof(cgs.defaultRankData.rankModelData.boltModelPath));
|
|
|
|
/*if ( !cgs.defaultRankData.boltModel ) {
|
|
Com_Printf(S_COLOR_RED "Unable to load model file: %s\n", token );
|
|
}*/
|
|
|
|
continue;
|
|
|
|
}
|
|
else if (!Q_stricmpn(token, "boltShader", 8)) {
|
|
if (COM_ParseString(&textPtr, &token)) {
|
|
continue;
|
|
}
|
|
|
|
Q_strncpyz(cgs.defaultRankData.rankModelData.boltShaderPath, token,
|
|
sizeof(cgs.defaultRankData.rankModelData.boltShaderPath));
|
|
|
|
/*cgs.defaultRankData.boltShader = trap_R_RegisterSkin( token );
|
|
if ( !cgs.defaultRankData.boltShader ) {
|
|
Com_Printf(S_COLOR_RED "Unable to load skin file: %s\n", token );
|
|
}*/
|
|
|
|
continue;
|
|
}
|
|
else if (!Q_stricmpn(token, "AdmiralRank", 11)) {
|
|
if (COM_ParseInt(&textPtr, &i)) {
|
|
continue;
|
|
}
|
|
|
|
cgs.defaultRankData.rankModelData.admiralRank = static_cast<qboolean>(i);
|
|
continue;
|
|
}
|
|
else if (!Q_stricmp(token, "}")) {
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
//if we succeeded in loading a default value (^_^!), then begin parsing the main ranks
|
|
if (!DefaultRankLoaded) {
|
|
Com_Printf(S_COLOR_RED "No default rank located in %s\n", fileName);
|
|
return qfalse;
|
|
}
|
|
else {
|
|
//Parse.Rank.Data? :) *sigh* if only rofl
|
|
while (1) {
|
|
token = COM_Parse(&textPtr);
|
|
if (!token[0]) {
|
|
break;
|
|
}
|
|
|
|
if (rankCount >= MAX_RANKS) {
|
|
break;
|
|
}
|
|
|
|
if (!Q_stricmpn(token, "{", 1)) {
|
|
|
|
while (1) {
|
|
token = COM_Parse(&textPtr);
|
|
if (!token[0]) {
|
|
break;
|
|
}
|
|
|
|
if (!Q_stricmpn(token, "ConsoleName", 11)) {
|
|
if (COM_ParseString(&textPtr, &token)) {
|
|
Com_Printf(S_COLOR_RED "Could not parse console rank name for rank number: %i\n", rankCount);
|
|
return qfalse;
|
|
}
|
|
|
|
Q_strncpyz(cgs.ranksData[rankCount].consoleName, token, sizeof(cgs.ranksData[rankCount].consoleName));
|
|
continue;
|
|
}
|
|
|
|
if (!Q_stricmpn(token, "FormalName", 10)) {
|
|
if (COM_ParseString(&textPtr, &token)) {
|
|
Com_Printf(S_COLOR_RED "Could not parse formal rank name for rank number: %i\n", rankCount);
|
|
return qfalse;
|
|
}
|
|
|
|
Q_strncpyz(cgs.ranksData[rankCount].formalName, token, sizeof(cgs.ranksData[rankCount].formalName));
|
|
continue;
|
|
}
|
|
|
|
if (!Q_stricmpn(token, "MenuTextureRed", 14)) {
|
|
if (CG_ParseRankData(&textPtr, &cgs.ranksData[rankCount].rankMenuData[CLR_RED])) {
|
|
Com_Printf(S_COLOR_RED "Could not parse red rank color for rank number: %i\n", rankCount);
|
|
return qfalse;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
else if (!Q_stricmpn(token, "MenuTextureTeal", 15)) {
|
|
if (CG_ParseRankData(&textPtr, &cgs.ranksData[rankCount].rankMenuData[CLR_TEAL])) {
|
|
Com_Printf(S_COLOR_RED "Could not parse teal rank color for rank number: %i\n", rankCount);
|
|
return qfalse;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
else if (!Q_stricmpn(token, "MenuTextureGold", 15)) {
|
|
if (CG_ParseRankData(&textPtr, &cgs.ranksData[rankCount].rankMenuData[CLR_GOLD])) {
|
|
Com_Printf(S_COLOR_RED "Could not parse teal rank color for rank number: %i\n", rankCount);
|
|
return qfalse;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
else if (!Q_stricmpn(token, "MenuTextureGreen", 16)) {
|
|
if (CG_ParseRankData(&textPtr, &cgs.ranksData[rankCount].rankMenuData[CLR_GREEN])) {
|
|
Com_Printf(S_COLOR_RED "Could not parse green rank color for rank number: %i\n", rankCount);
|
|
return qfalse;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
else if (!Q_stricmpn(token, "BoltModel", 9)) {
|
|
if (COM_ParseString(&textPtr, &token)) {
|
|
continue;
|
|
}
|
|
|
|
//cgs.ranksData[rankCount].boltModel = trap_R_RegisterModel( token );
|
|
|
|
Q_strncpyz(cgs.ranksData[rankCount].rankModelData.boltModelPath,
|
|
token,
|
|
sizeof(cgs.ranksData[rankCount].rankModelData.boltModelPath));
|
|
|
|
/*if ( !cgs.ranksData[rankCount].boltModel ) {
|
|
Com_Printf( S_COLOR_RED, "Could not load bolt model: %s\n", token );
|
|
}*/
|
|
continue;
|
|
}
|
|
else if (!Q_stricmpn(token, "boltShader", 8)) {
|
|
if (COM_ParseString(&textPtr, &token)) {
|
|
continue;
|
|
}
|
|
|
|
Q_strncpyz(cgs.ranksData[rankCount].rankModelData.boltShaderPath,
|
|
token,
|
|
sizeof(cgs.ranksData[rankCount].rankModelData.boltShaderPath));
|
|
|
|
|
|
/*if ( !cgs.ranksData[rankCount].boltShader ) {
|
|
Com_Printf( S_COLOR_RED, "Could not load bolt skin: %s\n", token );
|
|
}*/
|
|
continue;
|
|
}
|
|
else if (!Q_stricmpn(token, "AdmiralRank", 11)) {
|
|
if (COM_ParseInt(&textPtr, &i)) {
|
|
continue;
|
|
}
|
|
|
|
cgs.ranksData[rankCount].rankModelData.admiralRank = static_cast<qboolean>(i);
|
|
|
|
continue;
|
|
}
|
|
else if (!Q_stricmpn(token, "}", 1)) {
|
|
break;
|
|
}
|
|
}
|
|
rankCount++;
|
|
}
|
|
}
|
|
}
|
|
return qtrue;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
CG_LoadCrosshairs
|
|
By TiM
|
|
|
|
Parsing script to load
|
|
and display multiple
|
|
crosshairs.
|
|
=================
|
|
*/
|
|
qboolean CG_LoadCrosshairs(void) {
|
|
fileHandle_t f;
|
|
int32_t file_len;
|
|
char charText[20000];
|
|
char *token, *textPtr;
|
|
char *fileName = "ext_data/crosshairs.dat";
|
|
int32_t cHairCount = 0;
|
|
//int32_t i;
|
|
|
|
//load file and get file length
|
|
file_len = trap_FS_FOpenFile(fileName, &f, FS_READ);
|
|
|
|
memset(&charText, 0, sizeof(charText));
|
|
memset(&cgs.crosshairsData, 0, sizeof(&cgs.crosshairsData));
|
|
|
|
//check to see if we got anything
|
|
if (f == 0 || file_len <= 0) {
|
|
Com_Printf(S_COLOR_RED "Could not find file: %s\n", fileName);
|
|
return qfalse;
|
|
}
|
|
|
|
//check to see if we got too much
|
|
if (file_len > sizeof(charText)-1) {
|
|
Com_Printf(S_COLOR_RED "File %s waaaaay too big.\n", fileName);
|
|
return qfalse;
|
|
}
|
|
|
|
//read the data into the array
|
|
trap_FS_Read(charText, file_len, f);
|
|
|
|
//EOF?
|
|
charText[file_len] = 0;
|
|
|
|
trap_FS_FCloseFile(f);
|
|
|
|
COM_BeginParseSession();
|
|
|
|
textPtr = charText;
|
|
|
|
token = COM_Parse(&textPtr);
|
|
|
|
//wtf? Nothing here??
|
|
if (!token[0]) {
|
|
Com_Printf(S_COLOR_RED "File: %s terminated rather unexpectantly\n", fileName);
|
|
return qfalse;
|
|
}
|
|
|
|
if (Q_stricmp(token, "{")) {
|
|
Com_Printf(S_COLOR_RED "File: %s had no starting {\n", fileName);
|
|
return qfalse;
|
|
}
|
|
|
|
//now for the natural hard-core loop parsing bit
|
|
while (1) {
|
|
|
|
if (cHairCount >= MAX_CROSSHAIRS) {
|
|
break;
|
|
}
|
|
|
|
if (!Q_stricmpn(token, "{", 1)) {
|
|
//Make color default to white
|
|
VectorCopy(colorTable[CT_WHITE], cgs.crosshairsData[cHairCount].color);
|
|
cgs.crosshairsData[cHairCount].color[3] = 1.0f;
|
|
|
|
while (1)
|
|
{
|
|
token = COM_Parse(&textPtr);
|
|
if (!token[0]) {
|
|
break;
|
|
}
|
|
|
|
if (!Q_stricmpn(token, "noDraw", 6)) {
|
|
cgs.crosshairsData[cHairCount].noDraw = qtrue;
|
|
break;
|
|
}
|
|
else if (!Q_stricmpn(token, "CrosshairColor", 14)) {
|
|
if (COM_ParseVec4(&textPtr, cgs.crosshairsData[cHairCount].color)) {
|
|
Com_Printf(S_COLOR_RED "Invalid Color Value in %s\n", fileName);
|
|
return qfalse;
|
|
}
|
|
|
|
VectorScale(cgs.crosshairsData[cHairCount].color, 1.0f / 255.0f, cgs.crosshairsData[cHairCount].color);
|
|
cgs.crosshairsData[cHairCount].color[3] *= 1.0f / 255.0f;
|
|
|
|
continue;
|
|
}
|
|
else if (!Q_stricmpn(token, "BitmapCoords", 12)) {
|
|
if (COM_ParseString(&textPtr, &token)) {
|
|
Com_Printf(S_COLOR_RED "No bitmap co-ords found in %s\n", fileName);
|
|
return qfalse;
|
|
}
|
|
|
|
if (Q_stricmpn(token, "{", 1)) {
|
|
Com_Printf(S_COLOR_RED "No { found in bitmap co-ords in %s\n", fileName);
|
|
return qfalse;
|
|
}
|
|
|
|
//parse s1 value
|
|
if (COM_ParseString(&textPtr, &token)) {
|
|
Com_Printf(S_COLOR_RED "Bit co-ord value ended prematurely: %s\n", fileName);
|
|
return qfalse;
|
|
}
|
|
|
|
cgs.crosshairsData[cHairCount].s1 = atoi(token);
|
|
|
|
//parse t1 value
|
|
if (COM_ParseString(&textPtr, &token)) {
|
|
Com_Printf(S_COLOR_RED "Bit co-ord value ended prematurely: %s\n", fileName);
|
|
return qfalse;
|
|
}
|
|
|
|
cgs.crosshairsData[cHairCount].t1 = atoi(token);
|
|
|
|
//parse s2 value
|
|
if (COM_ParseString(&textPtr, &token)) {
|
|
Com_Printf(S_COLOR_RED "Bit co-ord value ended prematurely: %s\n", fileName);
|
|
return qfalse;
|
|
}
|
|
|
|
cgs.crosshairsData[cHairCount].s2 = atoi(token);
|
|
|
|
//parse t2 value
|
|
if (COM_ParseString(&textPtr, &token)) {
|
|
Com_Printf(S_COLOR_RED "Bit co-ord value ended prematurely: %s\n", fileName);
|
|
return qfalse;
|
|
}
|
|
|
|
cgs.crosshairsData[cHairCount].t2 = atoi(token);
|
|
|
|
//make sure we have } at the end FFS
|
|
if (COM_ParseString(&textPtr, &token)) {
|
|
Com_Printf(S_COLOR_RED "Bit co-ord value ended prematurely: %s\n", fileName);
|
|
return qfalse;
|
|
}
|
|
|
|
//This is needed or else we can't tell between this and the main closing }
|
|
if (Q_stricmpn(token, "}", 1)) {
|
|
Com_Printf(S_COLOR_RED "No terminating } in bitmap co-ord: %s\n", fileName);
|
|
return qfalse;
|
|
}
|
|
}
|
|
else if (!Q_stricmpn(token, "}", 1)) {
|
|
break;
|
|
}
|
|
}
|
|
cHairCount++;
|
|
}
|
|
|
|
token = COM_Parse(&textPtr);
|
|
if (!token[0]) {
|
|
break;
|
|
}
|
|
}
|
|
return qtrue;
|
|
}
|