DOOM-3-BFG

st_lib.cpp (5593B)

---

 /*
 ===========================================================================
 
 Doom 3 BFG Edition GPL Source Code
 Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company. 
 
 This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").  
 
 Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
 Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.
 
 In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.
 
 If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
 
 ===========================================================================
 */
 
 #include "Precompiled.h"
 #include "globaldata.h"
 
 #include <ctype.h>
 
 #include "doomdef.h"
 
 #include "z_zone.h"
 #include "v_video.h"
 
 #include "m_swap.h"
 
 #include "i_system.h"
 
 #include "w_wad.h"
 
 #include "st_stuff.h"
 #include "st_lib.h"
 #include "r_local.h"
 
 
 // in AM_map.c
 
 
 
 
 //
 // Hack display negative frags.
 //  Loads and store the stminus lump.
 //
 
 void STlib_init(void)
 {
     ::g->sttminus = (patch_t *) W_CacheLumpName("STTMINUS", PU_STATIC_SHARED);
 }
 
 
 // ?
 void
 STlib_initNum
 ( st_number_t*		n,
   int			x,
   int			y,
   patch_t**		pl,
   int*			num,
   qboolean*		on,
   int			width )
 {
     n->x	= x;
     n->y	= y;
     n->oldnum	= 0;
     n->width	= width;
     n->num	= num;
     n->on	= on;
     n->p	= pl;
 }
 
 
 // 
 // A fairly efficient way to draw a number
 //  based on differences from the old number.
 // Note: worth the trouble?
 //
 void
 STlib_drawNum
 ( st_number_t*	n,
   qboolean	refresh )
 {
 
     int		numdigits = n->width;
     int		num = *n->num;
     
     int		w = SHORT(n->p[0]->width);
     int		h = SHORT(n->p[0]->height);
     int		x = n->x;
     
     int		neg;
 
     n->oldnum = *n->num;
 
     neg = num < 0;
 
     if (neg)
     {
 	if (numdigits == 2 && num < -9)
 	    num = -9;
 	else if (numdigits == 3 && num < -99)
 	    num = -99;
 	
 	num = -num;
     }
 
     // clear the area
     x = n->x - numdigits*w;
 
     if (n->y - ST_Y < 0)
 	I_Error("drawNum: n->y - ST_Y < 0");
 
     V_CopyRect(x, n->y - ST_Y, BG, w*numdigits, h, x, n->y, FG);
 
     // if non-number, do not draw it
     if (num == 1994)
 	return;
 
     x = n->x;
 
     // in the special case of 0, you draw 0
     if (!num)
 	V_DrawPatch(x - w, n->y, FG, n->p[ 0 ]);
 
     // draw the new number
     while (num && numdigits--)
     {
 	x -= w;
 	V_DrawPatch(x, n->y, FG, n->p[ num % 10 ]);
 	num /= 10;
     }
 
     // draw a minus sign if necessary
     if (neg)
 	V_DrawPatch(x - 8, n->y, FG, ::g->sttminus);
 }
 
 
 //
 void
 STlib_updateNum
 ( st_number_t*		n,
   qboolean		refresh )
 {
     if (*n->on) STlib_drawNum(n, refresh);
 }
 
 
 //
 void
 STlib_initPercent
 ( st_percent_t*		p,
   int			x,
   int			y,
   patch_t**		pl,
   int*			num,
   qboolean*		on,
   patch_t*		percent )
 {
     STlib_initNum(&p->n, x, y, pl, num, on, 3);
     p->p = percent;
 }
 
 
 
 
 void
 STlib_updatePercent
 ( st_percent_t*		per,
   int			refresh )
 {
     if (refresh && *per->n.on)
 	V_DrawPatch(per->n.x, per->n.y, FG, per->p);
     
     STlib_updateNum(&per->n, refresh);
 }
 
 
 
 void
 STlib_initMultIcon
 ( st_multicon_t*	i,
   int			x,
   int			y,
   patch_t**		il,
   int*			inum,
   qboolean*		on )
 {
     i->x	= x;
     i->y	= y;
     i->oldinum 	= -1;
     i->inum	= inum;
     i->on	= on;
     i->p	= il;
 }
 
 
 
 void
 STlib_updateMultIcon
 ( st_multicon_t*	mi,
   qboolean		refresh )
 {
     int			w;
     int			h;
     int			x;
     int			y;
 
     if (*mi->on
 	&& (mi->oldinum != *mi->inum || refresh)
 	&& (*mi->inum!=-1))
     {
 	if (mi->oldinum != -1)
 	{
 	    x = mi->x - SHORT(mi->p[mi->oldinum]->leftoffset);
 	    y = mi->y - SHORT(mi->p[mi->oldinum]->topoffset);
 	    w = SHORT(mi->p[mi->oldinum]->width);
 	    h = SHORT(mi->p[mi->oldinum]->height);
 
 	    if (y - ST_Y < 0)
 			I_Error("updateMultIcon: y - ST_Y < 0");
 
 	    V_CopyRect(x, y-ST_Y, BG, w, h, x, y, FG);
 	}
 	V_DrawPatch(mi->x, mi->y, FG, mi->p[*mi->inum]);
 	mi->oldinum = *mi->inum;
     }
 }
 
 
 
 void
 STlib_initBinIcon
 ( st_binicon_t*		b,
   int			x,
   int			y,
   patch_t*		i,
   qboolean*		val,
   qboolean*		on )
 {
     b->x	= x;
     b->y	= y;
     b->oldval	= 0;
     b->val	= val;
     b->on	= on;
     b->p	= i;
 }
 
 
 
 void
 STlib_updateBinIcon
 ( st_binicon_t*		bi,
   qboolean		refresh )
 {
     int			x;
     int			y;
     int			w;
     int			h;
 
     if (*bi->on
 	&& (bi->oldval != *bi->val || refresh))
     {
 	x = bi->x - SHORT(bi->p->leftoffset);
 	y = bi->y - SHORT(bi->p->topoffset);
 	w = SHORT(bi->p->width);
 	h = SHORT(bi->p->height);
 
 	if (y - ST_Y < 0)
 	    I_Error("updateBinIcon: y - ST_Y < 0");
 
 	if (*bi->val)
 	    V_DrawPatch(bi->x, bi->y, FG, bi->p);
 	else
 	    V_CopyRect(x, y-ST_Y, BG, w, h, x, y, FG);
 
 	bi->oldval = *bi->val;
     }
 
 }