/*
================
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);
}
/*
===============
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;
gfixed frow, fcol;
gfixed size;
gfixed ax, ay, aw, ah;
ch &= 255;
if ( ch == ' ' ) {
return;
}
ax = MAKE_GFIXED(x);
ay = MAKE_GFIXED(y);
aw = MAKE_GFIXED(width);
ah = MAKE_GFIXED(height);
CG_AdjustFrom640( &ax, &ay, &aw, &ah );
row = ch>>4;
col = ch&15;
frow = MAKE_GFIXED(row)*GFIXED(0,0625);
fcol = MAKE_GFIXED(col)*GFIXED(0,0625);
size = GFIXED(0,0625);
_CG_trap_R_DrawStretchPic( ax, ay, aw, ah,
fcol, frow,
fcol + size, frow + size,
cgs.media.charsetShader );
}
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 );
}
static void CG_CalcVrect( void ) {
int xsize, ysize;
float lbheight;
// NERVE - SMF
if ( cg.limboMenu ) {
float x, y, w, h;
x = LIMBO_3D_X;
y = LIMBO_3D_Y;
w = LIMBO_3D_W;
h = LIMBO_3D_H;
cg.refdef.width = 0;
CG_AdjustFrom640( &x, &y, &w, &h );
cg.refdef.x = x;
cg.refdef.y = y;
cg.refdef.width = w;
cg.refdef.height = h;
return;
}
// -NERVE - SMF
// the intermission should allways be full screen
if ( cg.snap->ps.pm_type == PM_INTERMISSION ) {
xsize = ysize = 100;
} else {
// bound normal viewsize
if ( cg_viewsize.integer < 30 ) {
trap_Cvar_Set( "cg_viewsize","30" );
xsize = ysize = 30;
} else if ( cg_viewsize.integer > 100 ) {
trap_Cvar_Set( "cg_viewsize","100" );
xsize = ysize = 100;
} else {
xsize = ysize = cg_viewsize.integer;
}
}
//----(SA) added transition to/from letterbox
// normal aspect is xx:xx
// letterbox is yy:yy (85% of 'normal' height)
lbheight = ysize * 0.85;
if ( cg_letterbox.integer ) {
ysize = lbheight;
}
//----(SA) end
cg.refdef.width = cgs.glconfig.vidWidth * xsize / 100;
cg.refdef.width &= ~1;
cg.refdef.height = cgs.glconfig.vidHeight * ysize / 100;
cg.refdef.height &= ~1;
cg.refdef.x = ( cgs.glconfig.vidWidth - cg.refdef.width ) / 2;
cg.refdef.y = ( cgs.glconfig.vidHeight - cg.refdef.height ) / 2;
}
/*
================
CG_DrawPic
Coordinates are 640*480 virtual values
=================
*/
void CG_DrawPic( float x, float y, float width, float height, qhandle_t hShader ) {
float s0;
float s1;
float t0;
float t1;
if ( width < 0 ) { // flip about vertical
width = -width;
s0 = 1;
s1 = 0;
} else {
s0 = 0;
s1 = 1;
}
if ( height < 0 ) { // flip about horizontal
height = -height;
t0 = 1;
t1 = 0;
} else {
t0 = 0;
t1 = 1;
}
CG_AdjustFrom640( &x, &y, &width, &height );
trap_R_DrawStretchPic( x, y, width, height, s0, t0, s1, t1, hShader );
}
void CG_Text_PaintChar(float x, float y, float width, float height, float scale, float s, float t, float s2, float t2, qhandle_t hShader) {
float w, h;
w = width * scale;
h = height * scale;
CG_AdjustFrom640( &x, &y, &w, &h,qtrue);
trap_R_DrawStretchPic( x, y, w, h, s, t, s2, t2, hShader );
}
/*
===============
CG_DrawChar2
Coordinates and size in 640*480 virtual screen size
===============
*/
void CG_DrawChar2( 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 == ' ' ) {
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.menucharsetShader );
}
/*
=================
CG_Cinematic_f
=================
*/
void CG_Cinematic_f( void ) {
char arg[MAX_QPATH];
char s[6];
float x, y, width, height;
int bits = CIN_system;
Com_DPrintf("CG_Cinematic_f\n");
CG_StopCinematic_f();
trap_Argv( 1, arg, sizeof( arg ) );
trap_Argv( 2, s, sizeof( s ) );
if (s[0] == '1' || Q_stricmp(arg,"demoend.roq")==0 || Q_stricmp(arg,"end.roq")==0) {
bits |= CIN_hold;
}
if (s[0] == '2') {
bits |= CIN_loop;
}
//trap_S_StopAllSounds();
x = 0;
y = 0;
width = SCREEN_WIDTH;
height = SCREEN_HEIGHT;
CG_SetScreenPlacement( PLACE_CENTER, PLACE_CENTER );
CG_AdjustFrom640( &x, &y, &width, &height );
cg.cinematicHandle = trap_CIN_PlayCinematic( arg, x, y, width, height, bits );
}
/*
================
CG_DrawRotatedPic
Coordinates are 640*480 virtual values
=================
*/
void CG_DrawRotatedPic(float x, float y, float width, float height, qhandle_t hShader, float angle)
{
CG_AdjustFrom640(&x, &y, &width, &height);
trap_R_DrawRotatedPic(x, y, width, height, 0, 0, 1, 1, hShader, angle);
}
/*
==============
CG_FillRectGradient
==============
*/
void CG_FillRectGradient( float x, float y, float width, float height, const float *color, const float *gradcolor, int gradientType ) {
trap_R_SetColor( color );
CG_AdjustFrom640( &x, &y, &width, &height );
trap_R_DrawStretchPicGradient( x, y, width, height, 0, 0, 0, 0, cgs.media.whiteShader, gradcolor, gradientType );
trap_R_SetColor( NULL );
}
void CG_LimboPanel_RenderCounterNumber(float x, float y, float w, float h, float number, qhandle_t shaderBack, qhandle_t shaderRoll, int numbuttons) {
float numberS = (((numbuttons - 1) - number) + 0) * (1.f / numbuttons);
float numberE = (((numbuttons - 1) - number) + 1) * (1.f / numbuttons);
CG_AdjustFrom640(&x, &y, &w, &h);
trap_R_DrawStretchPic(x, y, w, h, 0, 0, 1, 1, shaderBack);
trap_R_DrawStretchPic(x, y, w, h, 0, numberS, 1, numberE, shaderRoll);
}
/*
================
CG_FillRect
Coordinates are 640*480 virtual values
=================
*/
void CG_FillRect( gfixed x, gfixed y, gfixed width, gfixed height, const gfixed *color ) {
_CG_trap_R_SetColor( color );
CG_AdjustFrom640( &x, &y, &width, &height );
_CG_trap_R_DrawStretchPic( x, y, width, height, GFIXED_0, GFIXED_0, GFIXED_0, GFIXED_0, cgs.media.whiteShader );
_CG_trap_R_SetColor( NULL );
}
/*
================
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, 1, 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 );
if (cg_horizontalPlacement == PLACE_STRETCH) {
size *= cgs.screenXScaleStretch;
} else {
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 );
if (cg_verticalPlacement == PLACE_STRETCH) {
size *= cgs.screenYScaleStretch;
} else {
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_DrawSides
Coords are virtual 640x480
================
*/
void CG_DrawSides( float x, float y, float w, float h, float size )
{
float sizeY;
CG_AdjustFrom640( &x, &y, &w, &h );
sizeY = size * cgs.screenYScale;
size *= cgs.screenXScale;
trap_R_DrawStretchPic( x, y + sizeY, size, h - ( sizeY * 2.0f ), 0, 0, 0, 0, cgs.media.whiteShader );
trap_R_DrawStretchPic( x + w - size, y + sizeY, size, h - ( sizeY * 2.0f ), 0, 0, 0, 0, cgs.media.whiteShader );
}
static void CG_DrawCorners( float x, float y, float w, float h, float size, qhandle_t pic )
{
float hs, vs;
CG_AdjustFrom640( &x, &y, &w, &h );
hs = size * cgs.screenXScale;
vs = size * cgs.screenYScale;
trap_R_DrawStretchPic( x, y, hs , vs, 0, 0, 0.5, 0.5, pic );
trap_R_DrawStretchPic( x, y + h - vs, hs, vs, 0, 0.5, 0.5, 1, pic );
trap_R_DrawStretchPic( x + w - hs, y, hs, vs, 0.5, 0, 1, 0.5, pic );
trap_R_DrawStretchPic( x + w - hs, y + h - vs, hs, vs, 0.5, 0.5, 1, 1, pic );
}
/*
================
CG_SetClipRegion
=================
*/
void CG_SetClipRegion( float x, float y, float w, float h ) {
vec4_t clip;
CG_AdjustFrom640( &x, &y, &w, &h );
clip[ 0 ] = x;
clip[ 1 ] = y;
clip[ 2 ] = x + w;
clip[ 3 ] = y + h;
trap_R_SetClipRegion( clip );
}
/*
================
CG_DrawFadePic
Coordinates are 640*480 virtual values
=================
*/
void CG_DrawFadePic( float x, float y, float width, float height, const Color::Color& fcolor,
const Color::Color& tcolor, float amount, qhandle_t hShader )
{
CG_AdjustFrom640( &x, &y, &width, &height );
Color::Color finalcolor = Color::Blend( fcolor, tcolor, amount / 100 );
trap_R_SetColor( finalcolor );
trap_R_DrawStretchPic( x, y, width, height, 0, 0, 1, 1, hShader );
trap_R_ClearColor();
}
/*
================
CG_FillAngleYaw (taken from iodfengine)
modified by @suburb
=================
*/
void CG_FillAngleYaw(float start, float end, float viewangle, float y, float height, int fov, const float *color) {
float x, width, fovscale;
fovscale = tan(DEG2RAD(fov / 2));
x = CG_WideX(SCREEN_WIDTH) / 2 + tan(DEG2RAD(viewangle + start)) / fovscale * CG_WideX(SCREEN_WIDTH) / 2;
width = fabs(CG_WideX(SCREEN_WIDTH) * (tan(DEG2RAD(viewangle + end)) - tan(DEG2RAD(viewangle + start))) / (fovscale * 2)) + 1;
if (etr_drawVelocitySnapping.integer == 2) {
width /= 2;
if (cg.predictedPlayerState.stats[STAT_USERCMD_MOVE] & UMOVE_RIGHT) {
x += width; // invert white bars if moving to the right
}
}
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_DrawFadePic
Coordinates are 640*480 virtual values
=================
*/
void CG_DrawFadePic( float x, float y, float width, float height, vec4_t fcolor,
vec4_t tcolor, float amount, qhandle_t hShader )
{
vec4_t finalcolor;
float inverse;
inverse = 100 - amount;
CG_AdjustFrom640( &x, &y, &width, &height );
finalcolor[ 0 ] = ( ( inverse * fcolor[ 0 ] ) + ( amount * tcolor[ 0 ] ) ) / 100;
finalcolor[ 1 ] = ( ( inverse * fcolor[ 1 ] ) + ( amount * tcolor[ 1 ] ) ) / 100;
finalcolor[ 2 ] = ( ( inverse * fcolor[ 2 ] ) + ( amount * tcolor[ 2 ] ) ) / 100;
finalcolor[ 3 ] = ( ( inverse * fcolor[ 3 ] ) + ( amount * tcolor[ 3 ] ) ) / 100;
trap_R_SetColor( finalcolor );
trap_R_DrawStretchPic( x, y, width, height, 0, 0, 1, 1, hShader );
trap_R_SetColor( NULL );
}
void CG_Draw3DModel( float x, float y, float w, float h, qhandle_t model, qhandle_t skin, vec3_t origin, vec3_t angles ) {
refdef_t refdef;
refEntity_t ent;
if ( !cg_draw3dIcons.integer || !cg_drawIcons.integer ) {
return;
}
CG_AdjustFrom640( &x, &y, &w, &h );
memset( &refdef, 0, sizeof( refdef ) );
memset( &ent, 0, sizeof( ent ) );
AnglesToAxis( angles, ent.axis );
VectorCopy( origin, ent.origin );
ent.hModel = model;
ent.customSkin = skin;
ent.renderfx = RF_NOSHADOW; // no stencil shadows
refdef.rdflags = RDF_NOWORLDMODEL;
AxisClear( refdef.viewaxis );
refdef.fov_x = 30;
refdef.fov_y = 30;
refdef.x = x;
refdef.y = y;
refdef.width = w;
refdef.height = h;
refdef.time = cg.time;
trap_R_ClearScene();
trap_R_AddRefEntityToScene( &ent );
trap_MME_TimeFraction(cg.timeFraction);
trap_R_RenderScene( &refdef );
}
/*
================
CG_DrawMinimap
================
*/
void CG_DrawMinimap( const rectDef_t* rect640, const vec4_t teamColor )
{
minimap_t* m = &cg.minimap;
minimapZone_t *z = NULL;
rectDef_t rect = *rect640;
CG_UpdateMinimapActive( m );
if( !m->active )
{
return;
}
z = CG_ChooseMinimapZone( m );
//Setup the transform
CG_AdjustFrom640( &rect.x, &rect.y, &rect.w, &rect.h );
CG_SetupMinimapTransform( &rect, m, z );
CG_SetMinimapColor( teamColor );
//Add the backgound
CG_FillRect( rect640->x, rect640->y, rect640->w, rect640->h, m->bgColor );
//Draw things inside the rectangle we were given
CG_SetScissor( rect.x, rect.y, rect.w, rect.h );
CG_EnableScissor( qtrue );
{
CG_MinimapDrawMap( m, z );
CG_MinimapDrawPlayer( m );
CG_MinimapDrawTeammates( m );
}
CG_EnableScissor( qfalse );
//Reset the color for other hud elements
trap_R_SetColor( NULL );
}
static void CG_DrawSkillBar(float x, float y, float w, float h, int skill)
{
int i;
float blockheight = (h - 4) / (float)(NUM_SKILL_LEVELS - 1);
float draw_y = y + h - blockheight;
vec4_t colour;
float x1, y1, w1, h1;
for (i = 0; i < NUM_SKILL_LEVELS - 1; i++)
{
if (i >= skill)
{
Vector4Set(colour, 1.f, 1.f, 1.f, .15f);
}
else
{
Vector4Set(colour, 0.f, 0.f, 0.f, .4f);
}
CG_FillRect(x, draw_y, w, blockheight, colour);
if (i < skill)
{
x1 = x;
y1 = draw_y;
w1 = w;
h1 = blockheight;
CG_AdjustFrom640(&x1, &y1, &w1, &h1);
trap_R_DrawStretchPic(x1, y1, w1, h1, 0, 0, 1.f, 0.5f, cgs.media.limboStar_roll);
}
CG_DrawRect_FixedBorder(x, draw_y, w, blockheight, 1, colorBlack);
draw_y -= (blockheight + 1);
}
}
/*
================
CG_Draw3DModel
================
*/
void CG_Draw3DModel( float x, float y, float w, float h, qhandle_t model, qhandle_t skin, vec3_t origin, vec3_t angles ) {
refdef_t refdef;
refEntity_t ent;
CG_AdjustFrom640( &x, &y, &w, &h,qtrue);
memset( &refdef, 0, sizeof( refdef ) );
memset( &ent, 0, sizeof( ent ) );
AnglesToAxis( angles, ent.axis );
VectorCopy( origin, ent.origin );
ent.hModel = model;
ent.customSkin = skin;
ent.renderfx = RF_NOSHADOW | RF_DEPTHHACK | RF_LIGHTING_ORIGIN;
refdef.rdflags = RDF_NOWORLDMODEL;
AxisClear(refdef.viewaxis);
refdef.fov_x = 30;
refdef.fov_y = 30;
refdef.x = x;
refdef.y = y;
refdef.width = w;
refdef.height = h;
refdef.time = cg.time;
trap_R_ClearScene();
trap_R_AddRefEntityToScene(&ent);
trap_R_RenderScene(&refdef);
}
/*
===============
CG_PainBlend
===============
*/
static void CG_PainBlend()
{
int damage;
float damageAsFracOfMax;
qhandle_t shader = cgs.media.viewBloodShader;
float x, y, w, h;
float s1, t1, s2, t2;
if ( cg.snap->ps.persistant[ PERS_SPECSTATE ] != SPECTATOR_NOT || cg.intermissionStarted )
{
return;
}
damage = cg.lastHealth - cg.snap->ps.stats[ STAT_HEALTH ];
if ( damage < 0 )
{
damage = 0;
}
damageAsFracOfMax = ( float ) damage / cg.snap->ps.stats[ STAT_MAX_HEALTH ];
cg.lastHealth = cg.snap->ps.stats[ STAT_HEALTH ];
cg.painBlendValue += damageAsFracOfMax * cg_painBlendScale.value;
if ( cg.painBlendValue > 0.0f )
{
cg.painBlendValue -= ( cg.frametime / 1000.0f ) *
cg_painBlendDownRate.value;
}
if ( cg.painBlendValue > 1.0f )
{
cg.painBlendValue = 1.0f;
}
else if ( cg.painBlendValue <= 0.0f )
{
cg.painBlendValue = 0.0f;
return;
}
Color::Color color;
if ( cg.snap->ps.persistant[ PERS_TEAM ] == TEAM_ALIENS )
{
color = { 0.43f, 0.8f, 0.37f };
}
else if ( cg.snap->ps.persistant[ PERS_TEAM ] == TEAM_HUMANS )
{
color = { 0.8f, 0.0f, 0.0f };
}
if ( cg.painBlendValue > cg.painBlendTarget )
{
cg.painBlendTarget += ( cg.frametime / 1000.0f ) *
cg_painBlendUpRate.value;
}
else if ( cg.painBlendValue < cg.painBlendTarget )
{
cg.painBlendTarget = cg.painBlendValue;
}
if ( cg.painBlendTarget > cg_painBlendMax.value )
{
cg.painBlendTarget = cg_painBlendMax.value;
}
color.SetAlpha( cg.painBlendTarget );
trap_R_SetColor( color );
//left
x = 0.0f;
y = 0.0f;
w = PAINBLEND_BORDER * 640.0f;
h = 480.0f;
CG_AdjustFrom640( &x, &y, &w, &h );
s1 = 0.0f;
t1 = 0.0f;
s2 = PAINBLEND_BORDER;
t2 = 1.0f;
CG_ScalePainBlendTCs( &s1, &t1, &s2, &t2 );
trap_R_DrawStretchPic( x, y, w, h, s1, t1, s2, t2, shader );
//right
x = 640.0f - ( PAINBLEND_BORDER * 640.0f );
y = 0.0f;
w = PAINBLEND_BORDER * 640.0f;
h = 480.0f;
CG_AdjustFrom640( &x, &y, &w, &h );
s1 = 1.0f - PAINBLEND_BORDER;
t1 = 0.0f;
s2 = 1.0f;
t2 = 1.0f;
CG_ScalePainBlendTCs( &s1, &t1, &s2, &t2 );
trap_R_DrawStretchPic( x, y, w, h, s1, t1, s2, t2, shader );
//top
x = PAINBLEND_BORDER * 640.0f;
y = 0.0f;
w = 640.0f - ( 2 * PAINBLEND_BORDER * 640.0f );
h = PAINBLEND_BORDER * 480.0f;
CG_AdjustFrom640( &x, &y, &w, &h );
s1 = PAINBLEND_BORDER;
t1 = 0.0f;
s2 = 1.0f - PAINBLEND_BORDER;
t2 = PAINBLEND_BORDER;
CG_ScalePainBlendTCs( &s1, &t1, &s2, &t2 );
trap_R_DrawStretchPic( x, y, w, h, s1, t1, s2, t2, shader );
//bottom
x = PAINBLEND_BORDER * 640.0f;
y = 480.0f - ( PAINBLEND_BORDER * 480.0f );
w = 640.0f - ( 2 * PAINBLEND_BORDER * 640.0f );
h = PAINBLEND_BORDER * 480.0f;
CG_AdjustFrom640( &x, &y, &w, &h );
s1 = PAINBLEND_BORDER;
t1 = 1.0f - PAINBLEND_BORDER;
s2 = 1.0f - PAINBLEND_BORDER;
t2 = 1.0f;
CG_ScalePainBlendTCs( &s1, &t1, &s2, &t2 );
trap_R_DrawStretchPic( x, y, w, h, s1, t1, s2, t2, shader );
trap_R_ClearColor();
}
/*
===============
UI_DrawPlayer
===============
*/
void UI_DrawPlayer( float x, float y, float w, float h, uiPlayerInfo_t *pi, int time ) {
refdef_t refdef;
refEntity_t legs = {0};
refEntity_t torso = {0};
refEntity_t head = {0};
#ifdef TA_WEAPSYS
refEntity_t gun[MAX_HANDS] = {0};
#else
refEntity_t gun = {0};
#endif
refEntity_t barrel = {0};
refEntity_t flash = {0};
vec3_t origin;
int renderfx;
vec3_t mins = {-16, -16, -24};
vec3_t maxs = {16, 16, 32};
float len;
float xx;
float xscale;
float yscale;
#ifdef TA_WEAPSYS
int i;
vec3_t angles;
#ifdef TURTLEARENA // PLAYERS
char *newTagNames[3] = { "tag_hand_primary", "tag_hand_secondary", NULL };
#endif
char *originalTagNames[3] = { "tag_weapon", "tag_flag", NULL };
#endif
if ( !pi->legsModel || !pi->torsoModel || !pi->headModel
#ifdef TA_PLAYERSYS
|| !pi->playercfg.animations[0].numFrames ) {
#else
|| !pi->animations[0].numFrames ) {
#endif
return;
}
// this allows the ui to cache the player model on the main menu
if (w == 0 || h == 0) {
return;
}
dp_realtime = time;
if ( pi->pendingWeapon != WP_NUM_WEAPONS && dp_realtime > pi->weaponTimer ) {
pi->weapon = pi->pendingWeapon;
pi->lastWeapon = pi->pendingWeapon;
pi->pendingWeapon = WP_NUM_WEAPONS;
pi->weaponTimer = 0;
#ifndef TA_WEAPSYS_EX
if( pi->currentWeapon != pi->weapon ) {
trap_S_StartLocalSound( weaponChangeSound, CHAN_LOCAL );
}
#endif
}
CG_AdjustFrom640( &x, &y, &w, &h );
y -= jumpHeight;
memset( &refdef, 0, sizeof( refdef ) );
memset( &legs, 0, sizeof(legs) );
memset( &torso, 0, sizeof(torso) );
memset( &head, 0, sizeof(head) );
refdef.rdflags = RDF_NOWORLDMODEL;
AxisClear( refdef.viewaxis );
refdef.x = x;
refdef.y = y;
refdef.width = w;
refdef.height = h;
if ( ui_stretch.integer ) {
xscale = cgs.screenXScaleStretch;
yscale = cgs.screenYScaleStretch;
} else {
xscale = cgs.screenXScale;
yscale = cgs.screenYScale;
}
refdef.fov_x = (int)((float)refdef.width / xscale / 640.0f * 90.0f);
xx = refdef.width / xscale / tan( refdef.fov_x / 360 * M_PI );
refdef.fov_y = atan2( refdef.height / yscale, xx );
refdef.fov_y *= ( 360 / (float)M_PI );
// calculate distance so the player nearly fills the box
len = 0.7 * ( maxs[2] - mins[2] );
origin[0] = len / tan( DEG2RAD(refdef.fov_x) * 0.5 );
origin[1] = 0.5 * ( mins[1] + maxs[1] );
origin[2] = -0.5 * ( mins[2] + maxs[2] );
refdef.time = dp_realtime;
trap_R_ClearScene();
// get the rotation information
UI_PlayerAngles( pi, legs.axis, torso.axis, head.axis );
// get the animation state (after rotation, to allow feet shuffle)
UI_PlayerAnimation( pi, &legs.oldframe, &legs.frame, &legs.backlerp,
&torso.oldframe, &torso.frame, &torso.backlerp );
renderfx = RF_LIGHTING_ORIGIN | RF_NOSHADOW;
//
// add the legs
//
legs.hModel = pi->legsModel;
legs.customSkin = CG_AddSkinToFrame( &pi->modelSkin );
VectorCopy( origin, legs.origin );
VectorCopy( origin, legs.lightingOrigin );
legs.renderfx = renderfx;
VectorCopy (legs.origin, legs.oldorigin);
Byte4Copy( pi->c1RGBA, legs.shaderRGBA );
CG_AddRefEntityWithMinLight( &legs );
if (!legs.hModel) {
return;
}
//
// add the torso
//
torso.hModel = pi->torsoModel;
if (!torso.hModel) {
return;
}
torso.customSkin = legs.customSkin;
VectorCopy( origin, torso.lightingOrigin );
UI_PositionRotatedEntityOnTag( &torso, &legs, pi->legsModel, "tag_torso");
torso.renderfx = renderfx;
Byte4Copy( pi->c1RGBA, torso.shaderRGBA );
CG_AddRefEntityWithMinLight( &torso );
//
// add the head
//
head.hModel = pi->headModel;
if (!head.hModel) {
return;
}
head.customSkin = legs.customSkin;
VectorCopy( origin, head.lightingOrigin );
UI_PositionRotatedEntityOnTag( &head, &torso, pi->torsoModel, "tag_head");
head.renderfx = renderfx;
Byte4Copy( pi->c1RGBA, head.shaderRGBA );
CG_AddRefEntityWithMinLight( &head );
//
// add the gun
//
if ( pi->currentWeapon != WP_NONE ) {
#ifdef TA_WEAPSYS
// get hands from cent
for (i = 0; i < MAX_HANDS; i++)
{
memset( &gun[i], 0, sizeof(gun[i]) );
gun[i].hModel = pi->weaponModel[i];
VectorCopy( origin, gun[i].lightingOrigin );
gun[i].renderfx = renderfx;
Byte4Copy( pi->c1RGBA, gun[i].shaderRGBA );
if (!originalTagNames[i]
#ifdef TURTLEARENA // PLAYERS
|| !newTagNames[i]
#endif
)
{
break;
}
if (!gun[i].hModel) {
continue;
}
if (
#ifdef TURTLEARENA // PLAYERS
!UI_PositionEntityOnTag( &gun[i], &torso, pi->torsoModel, newTagNames[i]) &&
#endif
!UI_PositionEntityOnTag( &gun[i], &torso, pi->torsoModel, originalTagNames[i]))
{
// Failed to find tag
continue;
}
CG_AddRefEntityWithMinLight( &gun[i] );
}
#else
memset( &gun, 0, sizeof(gun) );
gun.hModel = pi->weaponModel;
Byte4Copy( pi->c1RGBA, gun.shaderRGBA );
VectorCopy( origin, gun.lightingOrigin );
UI_PositionEntityOnTag( &gun, &torso, pi->torsoModel, "tag_weapon");
gun.renderfx = renderfx;
CG_AddRefEntityWithMinLight( &gun );
#endif
}
//
// add the spinning barrel
//
#ifdef TA_WEAPSYS
for (i = 0; i < MAX_HANDS; i++)
#else
if ( pi->barrelModel )
#endif
{
#ifdef TA_WEAPSYS
if (!pi->barrelModel[i])
continue;
#else
vec3_t angles;
#endif
memset( &barrel, 0, sizeof(barrel) );
VectorCopy( origin, barrel.lightingOrigin );
barrel.renderfx = renderfx;
#ifdef TA_WEAPSYS
barrel.hModel = pi->barrelModel[i];
VectorClear(angles);
if (bg_weapongroupinfo[pi->realWeapon].weapon[0]->barrelSpin != BS_NONE)
{
angles[bg_weapongroupinfo[pi->realWeapon].weapon[0]->barrelSpin]
= UI_MachinegunSpinAngle( pi );
}
#else
barrel.hModel = pi->barrelModel;
angles[YAW] = 0;
angles[PITCH] = 0;
angles[ROLL] = UI_MachinegunSpinAngle( pi );
#endif
AnglesToAxis( angles, barrel.axis );
#ifdef TA_WEAPSYS
UI_PositionRotatedEntityOnTag( &barrel, &gun[i], pi->weaponModel[i], "tag_barrel");
#else
UI_PositionRotatedEntityOnTag( &barrel, &gun, pi->weaponModel, "tag_barrel");
#endif
CG_AddRefEntityWithMinLight( &barrel );
}
//
// add muzzle flash
//
if ( dp_realtime <= pi->muzzleFlashTime ) {
#ifdef TA_WEAPSYS
vec3_t *flashDlightColor;
for (i = 0; i < MAX_HANDS; i++)
{
memset( &flash, 0, sizeof(flash) );
flash.hModel = pi->flashModel[i];
flashDlightColor = &pi->flashDlightColor[i];
Byte4Copy( pi->c1RGBA, flash.shaderRGBA );
if (!flash.hModel)
continue;
VectorCopy( origin, flash.lightingOrigin );
UI_PositionEntityOnTag( &flash, &gun[i], pi->weaponModel[i], "tag_flash");
flash.renderfx = renderfx;
trap_R_AddRefEntityToScene( &flash );
// make a dlight for the flash
if ( *flashDlightColor[0] || *flashDlightColor[1] || *flashDlightColor[2] ) {
trap_R_AddLightToScene( flash.origin, 200 + (rand()&31), 1.0f, *flashDlightColor[0],
*flashDlightColor[1], *flashDlightColor[2] );
}
}
#else
if ( pi->flashModel ) {
memset( &flash, 0, sizeof(flash) );
flash.hModel = pi->flashModel;
Byte4Copy( pi->c1RGBA, flash.shaderRGBA );
VectorCopy( origin, flash.lightingOrigin );
UI_PositionEntityOnTag( &flash, &gun, pi->weaponModel, "tag_flash");
flash.renderfx = renderfx;
CG_AddRefEntityWithMinLight( &flash );
}
// make a dlight for the flash
if ( pi->flashDlightColor[0] || pi->flashDlightColor[1] || pi->flashDlightColor[2] ) {
trap_R_AddJuniorLightToScene( flash.origin, 200 + (rand()&31), 1.0f, pi->flashDlightColor[0],
pi->flashDlightColor[1], pi->flashDlightColor[2] );
}
#endif
}
//
// add the chat icon
//
if ( pi->chat ) {
#ifdef TA_DATA // shaders
UI_PlayerFloatSprite( pi, torso.origin, trap_R_RegisterShaderNoMip( "sprites/talkBalloon" ) );
#else
UI_PlayerFloatSprite( pi, torso.origin, trap_R_RegisterShaderNoMip( "sprites/balloon3" ) );
#endif
}
//
// add an accent light
//
origin[0] -= 100; // + = behind, - = in front
origin[1] += 100; // + = left, - = right
origin[2] += 100; // + = above, - = below
trap_R_AddJuniorLightToScene( origin, 500, 1.0, 1.0, 1.0, 1.0 );
origin[0] -= 100;
origin[1] -= 100;
origin[2] -= 100;
trap_R_AddJuniorLightToScene( origin, 500, 1.0, 1.0, 0.0, 0.0 );
trap_R_RenderScene( &refdef );
}
/*
==========================
UI_FileExists
==========================
*/
static qboolean UI_FileExists(const char *filename) {
int len;
len = trap_FS_FOpenFile( filename, NULL, FS_READ );
if (len>0) {
return qtrue;
}
return qfalse;
}
/*
================
CG_DrawPicST
Allows passing of st co-ords
Coordinates are 640*480 virtual values
=================
*/
void CG_DrawPicST( float x, float y, float width, float height, float s0, float t0, float s1, float t1, qhandle_t hShader ) {
CG_AdjustFrom640( &x, &y, &width, &height );
trap_R_DrawStretchPic( x, y, width, height, s0, t0, s1, t1, hShader );
}
/*
================
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 );
}
static void Main_MenuDraw( void ) {
refdef_t refdef;
refEntity_t ent;
vec3_t origin;
vec3_t angles;
float adjust;
float x, y, w, h;
vec4_t color = {0.5, 0, 0, 1};
// setup the refdef
memset( &refdef, 0, sizeof( refdef ) );
refdef.rdflags = RDF_NOWORLDMODEL;
AxisClear( refdef.viewaxis );
x = 0;
y = 0;
w = 640;
h = 120;
CG_AdjustFrom640( &x, &y, &w, &h );
refdef.x = x;
refdef.y = y;
refdef.width = w;
refdef.height = h;
adjust = 0; // JDC: Kenneth asked me to stop this 1.0 * sin( (float)uis.realtime / 1000 );
refdef.fov_x = 60 + adjust;
refdef.fov_y = 19.6875 + adjust;
refdef.time = uis.realtime;
origin[0] = 300;
origin[1] = 0;
origin[2] = -32;
trap_R_ClearScene();
// add the model
memset( &ent, 0, sizeof(ent) );
adjust = 5.0 * sin( (float)uis.realtime / 5000 );
VectorSet( angles, 0, 180 + adjust, 0 );
AnglesToAxis( angles, ent.axis );
ent.hModel = s_main.bannerModel;
VectorCopy( origin, ent.origin );
VectorCopy( origin, ent.lightingOrigin );
ent.renderfx = RF_LIGHTING_ORIGIN | RF_NOSHADOW;
VectorCopy( ent.origin, ent.oldorigin );
CG_AddRefEntityWithMinLight( &ent );
trap_R_RenderScene( &refdef );
if (strlen(s_errorMessage.errorMessage))
{
UI_DrawProportionalString_AutoWrapped( 320, 192, 600, 20, s_errorMessage.errorMessage, UI_CENTER|UI_SMALLFONT|UI_DROPSHADOW, menu_text_color );
}
else
{
// standard menu drawing
Menu_Draw( &s_main.menu );
}
if (uis.demoversion) {
UI_DrawProportionalString( 320, 372, "DEMO FOR MATURE AUDIENCES DEMO", UI_CENTER|UI_SMALLFONT, color );
UI_DrawString( 320, 400, "Quake III Arena(c) 1999-2000, Id Software, Inc. All Rights Reserved", UI_CENTER|UI_SMALLFONT, color );
} else if (uis.demotestversion) {
UI_DrawProportionalString( 320, 372, "DEMOTEST FOR MATURE AUDIENCES DEMOTEST", UI_CENTER|UI_SMALLFONT, color );
UI_DrawString( 320, 400, "Quake III Arena(c) 1999-2000, Id Software, Inc. All Rights Reserved", UI_CENTER|UI_SMALLFONT, color );
UI_DrawString( 320, 428, "This test may only be distributed electronically. Physical media (e.g. CD-ROM's, floppies, etc.) redistribution of the demo test is prohibited. Refer to the End User License Agreement for further details.", UI_CENTER|UI_SMALLFONT, color );
} else {
UI_DrawString( 320, 450, "Quake III Arena(c) 1999-2000, Id Software, Inc. All Rights Reserved", UI_CENTER|UI_SMALLFONT, color );
}
}
