qf/quakeforge-old
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge-old synced 2025-03-13 04:24:24 +00:00
Code Issues Projects Releases Packages Wiki Activity

Non functional cvar code. Compiles, but won't run.

Browse source
This commit is contained in:
Dan Olson 2000-02-27 07:13:32 +00:00
parent 83a09156f1
commit 106dada0b2
115 changed files with 2955 additions and 1951 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
common/cd_audio.c
View file

@ -26,7 +26,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "quakedef.h"
#include "dosisms.h"
extern cvar_t bgmvolume;
extern cvar_t *bgmvolume;
#define ADDRESS_MODE_HSG 0
#define ADDRESS_MODE_RED_BOOK 1
@ -529,7 +529,7 @@ void CDAudio_Play(byte track, qboolean looping)
return;
}
volume = (int)(bgmvolume.value * 255.0);
volume = (int)(bgmvolume->value * 255.0);
if (volume < 0)
{
Cvar_SetValue ("bgmvolume", 0.0);
@ -772,7 +772,7 @@ void CDAudio_Update(void)
}
}
newVolume = (int)(bgmvolume.value * 255.0);
newVolume = (int)(bgmvolume->value * 255.0);
if (newVolume != cdvolume)
{
if (newVolume < 0)

8
common/cd_linux.c
View file

@ -295,18 +295,16 @@ void CDAudio_Update(void)
if (!enabled)
return;
if (bgmvolume.value != cdvolume)
if (bgmvolume->value != cdvolume)
{
if (cdvolume)
{
Cvar_SetValue ("bgmvolume", 0.0);
cdvolume = bgmvolume.value;
bgmvolume->value = cdvolume = 0.0;
CDAudio_Pause ();
}
else
{
Cvar_SetValue ("bgmvolume", 1.0);
cdvolume = bgmvolume.value;
bgmvolume->value = cdvolume = 1.0;
CDAudio_Resume ();
}
}

8
common/cd_sdl.c
View file

@ -121,19 +121,19 @@ void CDAudio_Resume()
void CDAudio_Update()
{
if(!cd_id || !enabled) return;
if(bgmvolume.value != cdvolume)
if(bgmvolume->value != cdvolume)
{
if(cdvolume)
{
Cvar_SetValue("bgmvolume",0.0);
bgmvolume->value = 0.0;
CDAudio_Pause();
}
else
{
Cvar_SetValue("bgmvolume",1.0);
bgmvolume->value = 1.0;
CDAudio_Resume();
}
cdvolume = bgmvolume.value;
cdvolume = bgmvolume->value;
return;
}
if(playLooping && (SDL_CDStatus(cd_id) != CD_PLAYING)

8
common/cd_win.c
View file

@ -39,7 +39,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include <cmd.h>
extern HWND mainwindow;
extern cvar_t bgmvolume;
extern cvar_t *bgmvolume;
static qboolean cdValid = false;
static qboolean playing = false;
@ -430,18 +430,18 @@ void CDAudio_Update(void)
if (!enabled)
return;
if (bgmvolume.value != cdvolume)
if (bgmvolume->value != cdvolume)
{
if (cdvolume)
{
Cvar_SetValue ("bgmvolume", 0.0);
cdvolume = bgmvolume.value;
cdvolume = bgmvolume->value;
CDAudio_Pause ();
}
else
{
Cvar_SetValue ("bgmvolume", 1.0);
cdvolume = bgmvolume.value;
cdvolume = bgmvolume->value;
CDAudio_Resume ();
}
}

50
common/cl_cam.c
View file

@ -47,7 +47,8 @@ static qboolean locked = false;
static int oldbuttons;
// track high fragger
cvar_t cl_hightrack = {"cl_hightrack", "0" };
//cvar_t cl_hightrack = {"cl_hightrack", "0" };
cvar_t *cl_hightrack;
//cvar_t cl_camera_maxpitch = {"cl_camera_maxpitch", "10" };
//cvar_t cl_camera_maxyaw = {"cl_camera_maxyaw", "30" };
@ -58,11 +59,17 @@ double cam_lastviewtime;
int spec_track = 0; // player# of who we are tracking
int autocam = CAM_NONE;
/*
cvar_t cl_chasecam = {"cl_chasecam", "0", CVAR_ARCHIVE};
cvar_t cl_chasecam_up = {"cl_chasecam_up", "16",CVAR_ARCHIVE};
cvar_t cl_chasecam_back = {"cl_chasecam_back", "100", CVAR_ARCHIVE};
cvar_t cl_chasecam_right = {"cl_chasecam_right", "0", CVAR_ARCHIVE};
*/
cvar_t * cl_chasecam;
cvar_t *cl_chasecam_up;
cvar_t *cl_chasecam_back;
cvar_t *cl_chasecam_right;
vec3_t chase_pos;
vec3_t chase_angles;
@ -71,10 +78,20 @@ vec3_t chase_dest;
vec3_t chase_dest_angles;
void Chase_Init (void) {
cl_chasecam = Cvar_Get ("cl_chasecam", "0", CVAR_ARCHIVE,
"None");
cl_chasecam_up = Cvar_Get ("cl_chasecam_up","16",CVAR_ARCHIVE,
"None");
cl_chasecam_back = Cvar_Get ("cl_chasecam_back","100",CVAR_ARCHIVE,
"None");
cl_chasecam_right = Cvar_Get ("cl_chasecam_right","0", CVAR_ARCHIVE,
"None");
/*
Cvar_RegisterVariable (&cl_chasecam);
Cvar_RegisterVariable (&cl_chasecam_up);
Cvar_RegisterVariable (&cl_chasecam_back);
Cvar_RegisterVariable (&cl_chasecam_right);
*/
}
void Chase_Reset (void) {
@ -104,9 +121,9 @@ void Chase_Update (void) {
// calc exact destination
for (i=0 ; i<3 ; i++)
chase_dest[i] = r_refdef.vieworg[i]
- forward[i] * cl_chasecam_back.value
- right[i] * cl_chasecam_right.value;
chase_dest[2] = r_refdef.vieworg[2] + cl_chasecam_up.value;
- forward[i] * cl_chasecam_back->value
- right[i] * cl_chasecam_right->value;
chase_dest[2] = r_refdef.vieworg[2] + cl_chasecam_up->value;
// find the spot the player is looking at
VectorMA (r_refdef.vieworg, 4096, forward, dest);
@ -164,7 +181,7 @@ qboolean Cam_DrawViewModel(void)
if (!cl.spectator)
return true;
if (autocam && locked && cl_chasecam.value)
if (autocam && locked && cl_chasecam->value)
return true;
return false;
}
@ -172,7 +189,7 @@ qboolean Cam_DrawViewModel(void)
// returns true if we should draw this player, we don't if we are chase camming
qboolean Cam_DrawPlayer(int playernum)
{
if (cl.spectator && autocam && locked && cl_chasecam.value &&
if (cl.spectator && autocam && locked && cl_chasecam->value &&
spec_track == playernum)
return false;
return true;
@ -391,7 +408,7 @@ void Cam_Track(usercmd_t *cmd)
if (!cl.spectator)
return;
if (cl_hightrack.value && !locked)
if (cl_hightrack->value && !locked)
Cam_CheckHighTarget();
if (!autocam || cls.state != ca_active)
@ -399,7 +416,7 @@ void Cam_Track(usercmd_t *cmd)
if (locked && (!cl.players[spec_track].name[0] || cl.players[spec_track].spectator)) {
locked = false;
if (cl_hightrack.value)
if (cl_hightrack->value)
Cam_CheckHighTarget();
else
Cam_Unlock();
@ -423,7 +440,7 @@ void Cam_Track(usercmd_t *cmd)
if (!locked || !autocam)
return;
if (cl_chasecam.value) {
if (cl_chasecam->value) {
cmd->forwardmove = cmd->sidemove = cmd->upmove = 0;
VectorCopy(player->viewangles, cl.viewangles);
@ -523,8 +540,8 @@ void Cam_SetView(void)
vectoangles(vec, vec2);
vec2[PITCH] = -vec2[PITCH];
cam_viewangles[PITCH] = adjustang(cam_viewangles[PITCH], vec2[PITCH], cl_camera_maxpitch.value);
cam_viewangles[YAW] = adjustang(cam_viewangles[YAW], vec2[YAW], cl_camera_maxyaw.value);
cam_viewangles[PITCH] = adjustang(cam_viewangles[PITCH], vec2[PITCH], cl_camera_maxpitch->value);
cam_viewangles[YAW] = adjustang(cam_viewangles[YAW], vec2[YAW], cl_camera_maxyaw->value);
}
VectorCopy(cam_viewangles, cl.viewangles);
VectorCopy(cl.viewangles, cl.simangles);
@ -558,8 +575,8 @@ void Cam_FinishMove(usercmd_t *cmd)
vectoangles(vec, vec2);
vec2[PITCH] = -vec2[PITCH];
cam_viewangles[PITCH] = adjustang(cam_viewangles[PITCH], vec2[PITCH], cl_camera_maxpitch.value);
cam_viewangles[YAW] = adjustang(cam_viewangles[YAW], vec2[YAW], cl_camera_maxyaw.value);
cam_viewangles[PITCH] = adjustang(cam_viewangles[PITCH], vec2[PITCH], cl_camera_maxpitch->value);
cam_viewangles[YAW] = adjustang(cam_viewangles[YAW], vec2[YAW], cl_camera_maxyaw->value);
}
VectorCopy(cam_viewangles, cl.viewangles);
}
@ -584,7 +601,7 @@ void Cam_FinishMove(usercmd_t *cmd)
return;
}
if (autocam && cl_hightrack.value) {
if (autocam && cl_hightrack->value) {
Cam_CheckHighTarget();
return;
}
@ -634,10 +651,13 @@ void Cam_Reset(void)
void CL_InitCam(void)
{
cl_hightrack = Cvar_Get ("cl_hightrack","0",0,"None");
/*
Cvar_RegisterVariable (&cl_hightrack);
Cvar_RegisterVariable (&cl_chasecam);
// Cvar_RegisterVariable (&cl_camera_maxpitch);
// Cvar_RegisterVariable (&cl_camera_maxyaw);
*/
}

13
common/cl_ents.c
View file

@ -31,9 +31,14 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include <cvars.h>
#include <model.h>
/*
extern cvar_t cl_predict_players;
extern cvar_t cl_predict_players2;
extern cvar_t cl_solid_players;
*/
extern cvar_t *cl_predict_players;
extern cvar_t *cl_predict_players2;
extern cvar_t *cl_solid_players;
static struct predicted_player {
int flags;
@ -828,7 +833,7 @@ void CL_LinkPlayers (void)
continue; // not present this frame
// spawn light flashes, even ones coming from invisible objects
if (!gl_flashblend.value || j != cl.playernum) {
if (!gl_flashblend->value || j != cl.playernum) {
if ((state->effects & (EF_BLUE | EF_RED)) == (EF_BLUE | EF_RED))
CL_NewDlight (j, state->origin[0], state->origin[1], state->origin[2], 200 + (rand()&31), 0.1, 3);
else if (state->effects & EF_BLUE)
@ -877,7 +882,7 @@ void CL_LinkPlayers (void)
// only predict half the move to minimize overruns
msec = 500*(playertime - state->state_time);
if (msec <= 0 || (!cl_predict_players.value && !cl_predict_players2.value))
if (msec <= 0 || (!cl_predict_players->value && !cl_predict_players2->value))
{
VectorCopy (state->origin, ent->origin);
//Con_DPrintf ("nopredict\n");
@ -998,7 +1003,7 @@ void CL_SetUpPlayerPrediction(qboolean dopred)
// only predict half the move to minimize overruns
msec = 500*(playertime - state->state_time);
if (msec <= 0 ||
(!cl_predict_players.value && !cl_predict_players2.value) ||
(!cl_predict_players->value && !cl_predict_players2->value) ||
!dopred)
{
VectorCopy (state->origin, pplayer->origin);
@ -1037,7 +1042,7 @@ void CL_SetSolidPlayers (int playernum)
struct predicted_player *pplayer;
physent_t *pent;
if (!cl_solid_players.value)
if (!cl_solid_players->value)
return;
pent = pmove.physents + pmove.numphysent;

59
common/cl_input.c
View file

@ -35,7 +35,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include <protocol.h>
#include <input.h>
cvar_t cl_nodelta = {"cl_nodelta","0"};
// cvar_t cl_nodelta = {"cl_nodelta","0"};
cvar_t *cl_nodelta;
/*
===============================================================================
@ -132,7 +133,7 @@ void IN_KLookUp (void) {KeyUp(&in_klook);}
void IN_MLookDown (void) {KeyDown(&in_mlook);}
void IN_MLookUp (void) {
KeyUp(&in_mlook);
if ( !(in_mlook.state&1) && lookspring.value)
if ( !(in_mlook.state&1) && lookspring->value)
V_StartPitchDrift();
}
void IN_UpDown(void) {KeyDown(&in_up);}
@ -229,7 +230,7 @@ float CL_KeyState (kbutton_t *key)
//==========================================================================
/*
cvar_t cl_upspeed = {"cl_upspeed","200"};
cvar_t cl_forwardspeed = {"cl_forwardspeed","200", CVAR_ARCHIVE};
cvar_t cl_backspeed = {"cl_backspeed","200", CVAR_ARCHIVE};
@ -241,7 +242,18 @@ cvar_t cl_yawspeed = {"cl_yawspeed","140"};
cvar_t cl_pitchspeed = {"cl_pitchspeed","150"};
cvar_t cl_anglespeedkey = {"cl_anglespeedkey","1.5"};
*/
cvar_t *cl_upspeed;
cvar_t *cl_forwardspeed;
cvar_t *cl_backspeed;
cvar_t *cl_sidespeed;
cvar_t *cl_movespeedkey;
cvar_t *cl_yawspeed;
cvar_t *cl_pitchspeed;
cvar_t *cl_anglespeedkey;
/*
================
@ -256,28 +268,28 @@ void CL_AdjustAngles (void)
float up, down;
if (in_speed.state & 1)
speed = host_frametime * cl_anglespeedkey.value;
speed = host_frametime * cl_anglespeedkey->value;
else
speed = host_frametime;
if (!(in_strafe.state & 1))
{
cl.viewangles[YAW] -= speed*cl_yawspeed.value*CL_KeyState (&in_right);
cl.viewangles[YAW] += speed*cl_yawspeed.value*CL_KeyState (&in_left);
cl.viewangles[YAW] -= speed*cl_yawspeed->value*CL_KeyState (&in_right);
cl.viewangles[YAW] += speed*cl_yawspeed->value*CL_KeyState (&in_left);
cl.viewangles[YAW] = anglemod(cl.viewangles[YAW]);
}
if (in_klook.state & 1)
{
V_StopPitchDrift ();
cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * CL_KeyState (&in_forward);
cl.viewangles[PITCH] += speed*cl_pitchspeed.value * CL_KeyState (&in_back);
cl.viewangles[PITCH] -= speed*cl_pitchspeed->value * CL_KeyState (&in_forward);
cl.viewangles[PITCH] += speed*cl_pitchspeed->value * CL_KeyState (&in_back);
}
up = CL_KeyState (&in_lookup);
down = CL_KeyState(&in_lookdown);
cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * up;
cl.viewangles[PITCH] += speed*cl_pitchspeed.value * down;
cl.viewangles[PITCH] -= speed*cl_pitchspeed->value * up;
cl.viewangles[PITCH] += speed*cl_pitchspeed->value * down;
if (up || down)
V_StopPitchDrift ();
@ -315,20 +327,20 @@ void CL_BaseMove (usercmd_t *cmd)
#endif
if (in_strafe.state & 1)
{
cmd->sidemove += cl_sidespeed.value * CL_KeyState (&in_right);
cmd->sidemove -= cl_sidespeed.value * CL_KeyState (&in_left);
cmd->sidemove += cl_sidespeed->value * CL_KeyState (&in_right);
cmd->sidemove -= cl_sidespeed->value * CL_KeyState (&in_left);
}
cmd->sidemove += cl_sidespeed.value * CL_KeyState (&in_moveright);
cmd->sidemove -= cl_sidespeed.value * CL_KeyState (&in_moveleft);
cmd->sidemove += cl_sidespeed->value * CL_KeyState (&in_moveright);
cmd->sidemove -= cl_sidespeed->value * CL_KeyState (&in_moveleft);
cmd->upmove += cl_upspeed.value * CL_KeyState (&in_up);
cmd->upmove -= cl_upspeed.value * CL_KeyState (&in_down);
cmd->upmove += cl_upspeed->value * CL_KeyState (&in_up);
cmd->upmove -= cl_upspeed->value * CL_KeyState (&in_down);
if (! (in_klook.state & 1) )
{
cmd->forwardmove += cl_forwardspeed.value * CL_KeyState (&in_forward);
cmd->forwardmove -= cl_backspeed.value * CL_KeyState (&in_back);
cmd->forwardmove += cl_forwardspeed->value * CL_KeyState (&in_forward);
cmd->forwardmove -= cl_backspeed->value * CL_KeyState (&in_back);
}
//
@ -336,9 +348,9 @@ void CL_BaseMove (usercmd_t *cmd)
//
if (in_speed.state & 1)
{
cmd->forwardmove *= cl_movespeedkey.value;
cmd->sidemove *= cl_movespeedkey.value;
cmd->upmove *= cl_movespeedkey.value;
cmd->forwardmove *= cl_movespeedkey->value;
cmd->sidemove *= cl_movespeedkey->value;
cmd->upmove *= cl_movespeedkey->value;
}
#ifdef QUAKE2
@ -486,7 +498,7 @@ void CL_SendCmd (void)
if (cls.netchan.outgoing_sequence - cl.validsequence >= UPDATE_BACKUP-1)
cl.validsequence = 0;
if (cl.validsequence && !cl_nodelta.value && cls.state == ca_active &&
if (cl.validsequence && !cl_nodelta->value && cls.state == ca_active &&
!cls.demorecording)
{
cl.frames[cls.netchan.outgoing_sequence&UPDATE_MASK].delta_sequence = cl.validsequence;
@ -625,7 +637,8 @@ void CL_InitInput (void)
Cmd_AddCommand ("+mlook", IN_MLookDown);
Cmd_AddCommand ("-mlook", IN_MLookUp);
Cvar_RegisterVariable (&cl_nodelta);
cl_nodelta = Cvar_Get ("cl_nodelta","0",0,"None");
// Cvar_RegisterVariable (&cl_nodelta);
}
/*

294
common/cl_main.c
View file

@ -91,38 +91,60 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
qboolean noclip_anglehack; // remnant from old quake
cvar_t rcon_password = {"rcon_password", "", CVAR_NONE};
//cvar_t rcon_password = {"rcon_password", "", CVAR_NONE};
cvar_t *rcon_password;
cvar_t rcon_address = {"rcon_address", ""};
//cvar_t rcon_address = {"rcon_address", ""};
cvar_t *rcon_address;
cvar_t cl_timeout = {"cl_timeout", "60"};
//cvar_t cl_timeout = {"cl_timeout", "60"};
cvar_t *cl_timeout;
// these two are not intended to be set directly
cvar_t cl_name = {"_cl_name", "player", CVAR_ARCHIVE};
cvar_t cl_color = {"_cl_color", "0", CVAR_ARCHIVE};
//cvar_t cl_name = {"_cl_name", "player", CVAR_ARCHIVE};
//cvar_t cl_color = {"_cl_color", "0", CVAR_ARCHIVE};
cvar_t *cl_name;
cvar_t *cl_color;
cvar_t cl_shownet = {"cl_shownet","0"}; // can be 0, 1, or 2
cvar_t cl_nolerp = {"cl_nolerp","0"};
//cvar_t cl_shownet = {"cl_shownet","0"}; // can be 0, 1, or 2
//cvar_t cl_nolerp = {"cl_nolerp","0"};
cvar_t *cl_shownet;
cvar_t *cl_nolerp;
cvar_t cl_sbar = {"cl_sbar", "1", CVAR_ARCHIVE};
cvar_t cl_hudswap = {"cl_hudswap", "1", CVAR_ARCHIVE};
cvar_t cl_maxfps = {"cl_maxfps", "0", CVAR_ARCHIVE};
//cvar_t cl_sbar = {"cl_sbar", "1", CVAR_ARCHIVE};
//cvar_t cl_hudswap = {"cl_hudswap", "1", CVAR_ARCHIVE};
//cvar_t cl_maxfps = {"cl_maxfps", "0", CVAR_ARCHIVE};
cvar_t *cl_sbar;
cvar_t *cl_hudswap;
cvar_t *cl_maxfps;
cvar_t lookspring = {"lookspring","0", CVAR_ARCHIVE};
cvar_t lookstrafe = {"lookstrafe","0", CVAR_ARCHIVE};
cvar_t sensitivity = {"sensitivity","3", CVAR_ARCHIVE};
//cvar_t lookspring = {"lookspring","0", CVAR_ARCHIVE};
//cvar_t lookstrafe = {"lookstrafe","0", CVAR_ARCHIVE};
//cvar_t sensitivity = {"sensitivity","3", CVAR_ARCHIVE};
cvar_t *lookspring;
cvar_t *lookstrafe;
cvar_t *sensitivity;
cvar_t m_pitch = {"m_pitch","0.022", CVAR_ARCHIVE};
cvar_t m_yaw = {"m_yaw","0.022", CVAR_ARCHIVE};
cvar_t m_forward = {"m_forward","1", CVAR_ARCHIVE};
cvar_t m_side = {"m_side","0.8", CVAR_ARCHIVE};
//cvar_t m_pitch = {"m_pitch","0.022", CVAR_ARCHIVE};
//cvar_t m_yaw = {"m_yaw","0.022", CVAR_ARCHIVE};
//cvar_t m_forward = {"m_forward","1", CVAR_ARCHIVE};
//cvar_t m_side = {"m_side","0.8", CVAR_ARCHIVE};
cvar_t *m_pitch;
cvar_t *m_yaw;
cvar_t *m_forward;
cvar_t *m_side;
cvar_t entlatency = {"entlatency", "20"};
cvar_t cl_predict_players = {"cl_predict_players", "1"};
cvar_t cl_predict_players2 = {"cl_predict_players2", "1"};
cvar_t cl_solid_players = {"cl_solid_players", "1"};
//cvar_t entlatency = {"entlatency", "20"};
//cvar_t cl_predict_players = {"cl_predict_players", "1"};
//cvar_t cl_predict_players2 = {"cl_predict_players2", "1"};
//cvar_t cl_solid_players = {"cl_solid_players", "1"};
cvar_t *entlatency;
cvar_t *cl_predict_players;
cvar_t *cl_predict_players2;
cvar_t *cl_solid_players;
cvar_t localid = {"localid", ""};
//cvar_t localid = {"localid", ""};
cvar_t *localid;
#ifdef QUAKEWORLD
static qboolean allowremotecmd = true;
@ -131,19 +153,29 @@ static qboolean allowremotecmd = true;
//
// info mirrors
//
cvar_t password = {"password", "", CVAR_USERINFO|CVAR_SERVERINFO };
cvar_t spectator = {"spectator", "",CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t name = {"name","unnamed", CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t team = {"team","", CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t skin = {"skin","", CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t topcolor = {"topcolor","0", CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t bottomcolor = {"bottomcolor","0", CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t rate = {"rate","2500", CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t noaim = {"noaim","0", CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t msg = {"msg","1", CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO};
extern cvar_t cl_hightrack;
//cvar_t password = {"password", "", CVAR_USERINFO|CVAR_SERVERINFO };
cvar_t *password;
//cvar_t spectator = {"spectator", "",CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *spectator;
//cvar_t name = {"name","unnamed", CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *name;
//cvar_t team = {"team","", CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *team;
//cvar_t skin = {"skin","", CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *skin;
//cvar_t topcolor = {"topcolor","0", CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *topcolor;
//cvar_t bottomcolor = {"bottomcolor","0", CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *bottomcolor;
//cvar_t rate = {"rate","2500", CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *rate;
//cvar_t noaim = {"noaim","0", CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *noaim;
//cvar_t msg = {"msg","1", CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *msg;
//extern cvar_t cl_hightrack;
extern cvar_t *cl_hightrack;
client_static_t cls;
client_state_t cl;
@ -178,9 +210,12 @@ byte *host_colormap;
netadr_t master_adr; // address of the master server
cvar_t host_speeds = {"host_speeds","0"}; // set for running times
cvar_t show_fps = {"show_fps","0"}; // set for running times
cvar_t developer = {"developer","0"};
//cvar_t host_speeds = {"host_speeds","0"}; // set for running times
cvar_t *host_speeds;
//cvar_t show_fps = {"show_fps","0"}; // set for running times
cvar_t *show_fps;
//cvar_t developer = {"developer","0"};
cvar_t *developer;
void Master_Connect_f (void);
@ -443,8 +478,8 @@ void CL_ConnectionlessPacket (void)
while (*s && isspace(s[strlen(s) - 1]))
s[strlen(s) - 1] = 0;
if (!allowremotecmd && (!*localid.string || strcmp(localid.string, s))) {
if (!*localid.string) {
if (!allowremotecmd && (!*localid->string || strcmp(localid->string, s))) {
if (!*localid->string) {
Con_Printf("===========================\n");
Con_Printf("Command packet received from local host, but no "
"localid has been set. You may need to upgrade your server "
@ -456,7 +491,7 @@ void CL_ConnectionlessPacket (void)
Con_Printf("Invalid localid on command packet received from local host. "
"\n|%s| != |%s|\n"
"You may need to reload your server browser and QuakeWorld.\n",
s, localid.string);
s, localid->string);
Con_Printf("===========================\n");
Cvar_Set("localid", "");
return;
@ -777,7 +812,7 @@ float CL_LerpPoint (void)
f = cl.mtime[0] - cl.mtime[1];
if (!f || cl_nolerp.value || cls.timedemo || sv.active)
if (!f || cl_nolerp->value || cls.timedemo || sv.active)
{
cl.time = cl.mtime[0];
return 1;
@ -958,7 +993,7 @@ void CL_Rcon_f (void)
int i;
netadr_t to;
if (!rcon_password.string)
if (!rcon_password->string)
{
Con_Printf ("You must set 'rcon_password' before\n"
"issuing an rcon command.\n");
@ -973,7 +1008,7 @@ void CL_Rcon_f (void)
strcat (message, "rcon ");
strcat (message, rcon_password.string);
strcat (message, rcon_password->string);
strcat (message, " ");
for (i=1 ; i<Cmd_Argc() ; i++)
@ -986,7 +1021,7 @@ void CL_Rcon_f (void)
to = cls.netchan.remote_address;
else
{
if (!strlen(rcon_address.string))
if (!strlen(rcon_address->string))
{
Con_Printf ("You must either be connected,\n"
"or set the 'rcon_address' cvar\n"
@ -994,7 +1029,7 @@ void CL_Rcon_f (void)
return;
}
NET_StringToAdr (rcon_address.string, &to);
NET_StringToAdr (rcon_address->string, &to);
}
NET_SendPacket (strlen(message)+1, message
@ -1029,7 +1064,7 @@ int CL_ReadFromServer (void)
CL_ParseServerMessage ();
} while (ret && cls.state >= ca_connected);
if (cl_shownet.value)
if (cl_shownet->value)
Con_Printf ("\n");
CL_RelinkEntities ();
@ -1090,7 +1125,7 @@ void CL_ReadPackets (void)
// check timeout
//
if (cls.state >= ca_connected
&& realtime - cls.netchan.last_received > cl_timeout.value)
&& realtime - cls.netchan.last_received > cl_timeout->value)
{
Con_Printf ("\nServer connection timed out.\n");
CL_Disconnect ();
@ -1310,7 +1345,7 @@ void CL_RelinkEntities (void)
ent->forcelink = false;
if (i == cl.playernum + 1 && !cl_chasecam.value)
if (i == cl.playernum + 1 && !cl_chasecam->value)
continue;
#ifdef QUAKE2
@ -1484,10 +1519,10 @@ Con_DPrintf ("CL_SignonReply: %i\n", cls.signon);
case 2:
MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
MSG_WriteString (&cls.netchan.message, va("name \"%s\"\n", cl_name.string));
MSG_WriteString (&cls.netchan.message, va("name \"%s\"\n", cl_name->string));
MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
MSG_WriteString (&cls.netchan.message, va("color %i %i\n", ((int)cl_color.value)>>4, ((int)cl_color.value)&15));
MSG_WriteString (&cls.netchan.message, va("color %i %i\n", ((int)cl_color->value)>>4, ((int)cl_color->value)&15));
MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
snprintf(str, sizeof(str), "spawn %s", cls.spawnparms);
@ -1650,8 +1685,10 @@ CL_Init
void CL_Init (void)
{
#ifdef QUAKEWORLD
extern cvar_t baseskin;
extern cvar_t noskins;
// extern cvar_t baseskin;
extern cvar_t *baseskin;
// extern cvar_t noskins;
extern cvar_t *noskins;
#endif
#ifdef UQUAKE
@ -1681,66 +1718,127 @@ void CL_Init (void)
//
// register our commands
//
Cvar_RegisterVariable (&show_fps);
Cvar_RegisterVariable (&host_speeds);
Cvar_RegisterVariable (&developer);
// Cvar_RegisterVariable (&show_fps);
show_fps = Cvar_Get ("show_fps","0",0,"None");
// Cvar_RegisterVariable (&host_speeds);
host_speeds = Cvar_Get ("host_speeds","0",0,"None");
// Cvar_RegisterVariable (&developer);
developer = Cvar_Get ("developer","0",0,"None");
#ifdef QUAKEWOLRD
Cvar_RegisterVariable (&cl_warncmd);
// Cvar_RegisterVariable (&cl_warncmd);
cl_warncmd = Cvar_Get ("cl_warncmd","0",0,"None");
#endif
Cvar_RegisterVariable (&cl_name);
Cvar_RegisterVariable (&cl_color);
Cvar_RegisterVariable (&cl_upspeed);
Cvar_RegisterVariable (&cl_forwardspeed);
Cvar_RegisterVariable (&cl_backspeed);
Cvar_RegisterVariable (&cl_sidespeed);
Cvar_RegisterVariable (&cl_movespeedkey);
Cvar_RegisterVariable (&cl_yawspeed);
Cvar_RegisterVariable (&cl_pitchspeed);
Cvar_RegisterVariable (&cl_anglespeedkey);
Cvar_RegisterVariable (&cl_shownet);
Cvar_RegisterVariable (&cl_nolerp);
Cvar_RegisterVariable (&cl_sbar);
Cvar_RegisterVariable (&cl_hudswap);
Cvar_RegisterVariable (&cl_maxfps);
Cvar_RegisterVariable (&cl_timeout);
Cvar_RegisterVariable (&lookspring);
Cvar_RegisterVariable (&lookstrafe);
Cvar_RegisterVariable (&sensitivity);
// Cvar_RegisterVariable (&cl_name);
cl_name = Cvar_Get ("_cl_name","player",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&cl_color);
cl_color = Cvar_Get ("_cl_color","0",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&cl_upspeed);
cl_upspeed = Cvar_Get ("cl_upspeed","200",0,"None");
// Cvar_RegisterVariable (&cl_forwardspeed);
cl_forwardspeed = Cvar_Get ("cl_forwardspeed","200",CVAR_ARCHIVE,
"None");
// Cvar_RegisterVariable (&cl_backspeed);
cl_backspeed = Cvar_Get ("cl_backspeed","200",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&cl_sidespeed);
cl_sidespeed = Cvar_Get ("cl_sidespeed","350",0,"None");
// Cvar_RegisterVariable (&cl_movespeedkey);
cl_movespeedkey = Cvar_Get ("cl_movespeedkey","2.0",0,"None");
// Cvar_RegisterVariable (&cl_yawspeed);
cl_yawspeed = Cvar_Get ("cl_yawspeed","140",0,"None");
// Cvar_RegisterVariable (&cl_pitchspeed);
cl_pitchspeed = Cvar_Get ("cl_pitchspeed","150",0,"None");
// Cvar_RegisterVariable (&cl_anglespeedkey);
cl_anglespeedkey = Cvar_Get ("cl_anglespeedkey","1.5",0,"None");
// Cvar_RegisterVariable (&cl_shownet);
cl_shownet = Cvar_Get ("cl_shownet","0",0,"None");
// Cvar_RegisterVariable (&cl_nolerp);
cl_nolerp = Cvar_Get ("cl_nolerp","0",0,"None");
// Cvar_RegisterVariable (&cl_sbar);
cl_sbar = Cvar_Get ("cl_sbar","1",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&cl_hudswap);
cl_hudswap = Cvar_Get ("cl_hudswap","1",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&cl_maxfps);
cl_maxfps = Cvar_Get ("cl_maxfps","0",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&cl_timeout);
cl_timeout = Cvar_Get ("cl_timeout","60",0,"None");
// Cvar_RegisterVariable (&lookspring);
lookspring = Cvar_Get ("lookspring","0",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&lookstrafe);
lookstrafe = Cvar_Get ("lookstrafe","0",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&sensitivity);
sensitivity = Cvar_Get ("sensitivity","3",CVAR_ARCHIVE,"None");
Cvar_RegisterVariable (&m_pitch);
Cvar_RegisterVariable (&m_yaw);
Cvar_RegisterVariable (&m_forward);
Cvar_RegisterVariable (&m_side);
// Cvar_RegisterVariable (&m_pitch);
m_pitch = Cvar_Get ("m_pitch","0.022",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&m_yaw);
m_yaw = Cvar_Get ("m_yaw","0.022",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&m_forward);
m_forward = Cvar_Get ("m_forward","1",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&m_side);
m_side = Cvar_Get ("m_side","0.8",CVAR_ARCHIVE,"None");
Cvar_RegisterVariable (&rcon_password);
Cvar_RegisterVariable (&rcon_address);
// Cvar_RegisterVariable (&rcon_password);
rcon_password = Cvar_Get ("rcon_password","",0,"None");
// Cvar_RegisterVariable (&rcon_address);
rcon_address = Cvar_Get ("rcon_address","",0,"None");
Cvar_RegisterVariable (&entlatency);
Cvar_RegisterVariable (&cl_predict_players2);
Cvar_RegisterVariable (&cl_predict_players);
Cvar_RegisterVariable (&cl_solid_players);
// Cvar_RegisterVariable (&entlatency);
entlatency = Cvar_Get ("entlatency","20",0,"None");
// Cvar_RegisterVariable (&cl_predict_players2);
cl_predict_players2 = Cvar_Get ("cl_predict_players2","1",0,"None");
// Cvar_RegisterVariable (&cl_predict_players);
cl_predict_players = Cvar_Get ("cl_predict_players","1",0,"None");
// Cvar_RegisterVariable (&cl_solid_players);
cl_solid_players = Cvar_Get ("cl_solid_players","1",0,"None");
Cvar_RegisterVariable (&localid);
// Cvar_RegisterVariable (&localid);
localid = Cvar_Get ("localid","",0,"None");
#ifdef QUAKEWORLD
Cvar_RegisterVariable (&baseskin);
Cvar_RegisterVariable (&noskins);
// Cvar_RegisterVariable (&baseskin);
baseskin = Cvar_Get ("baseskin","base",0,"None");
// Cvar_RegisterVariable (&noskins);
noskins = Cvar_Get ("noskins","0",0,"None");
//
// info mirrors
//
Cvar_RegisterVariable (&name);
// Cvar_RegisterVariable (&name);
name = Cvar_Get ("name","unnamed",
CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO,"None");
#endif
Cvar_RegisterVariable (&password);
Cvar_RegisterVariable (&spectator);
Cvar_RegisterVariable (&skin);
Cvar_RegisterVariable (&team);
Cvar_RegisterVariable (&topcolor);
Cvar_RegisterVariable (&bottomcolor);
Cvar_RegisterVariable (&rate);
Cvar_RegisterVariable (&msg);
Cvar_RegisterVariable (&noaim);
// Cvar_RegisterVariable (&password);
password = Cvar_Get ("password","",CVAR_USERINFO|CVAR_SERVERINFO,
"None");
// Cvar_RegisterVariable (&spectator);
spectator = Cvar_Get ("spectator","",CVAR_USERINFO|CVAR_SERVERINFO,
"None");
// Cvar_RegisterVariable (&skin);
skin = Cvar_Get ("skin","",CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO,
"None");
// Cvar_RegisterVariable (&team);
team = Cvar_Get ("team","",CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO,
"None");
// Cvar_RegisterVariable (&topcolor);
topcolor = Cvar_Get ("topcolor","0",
CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO,
"None");
// Cvar_RegisterVariable (&bottomcolor);
bottomcolor = Cvar_Get ("bottomcolor","0",
CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO,
"None");
// Cvar_RegisterVariable (&rate);
rate = Cvar_Get ("rate","2500",
CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO,
"None");
// Cvar_RegisterVariable (&msg);
msg = Cvar_Get ("msg","1",CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO,
"None");
// Cvar_RegisterVariable (&noaim);
noaim = Cvar_Get ("noaim","0",
CVAR_ARCHIVE|CVAR_USERINFO|CVAR_SERVERINFO,
"None");

58
common/client.h
View file

@ -354,45 +354,45 @@ extern client_state_t cl;
// cvars
//
#ifdef UQUAKE
extern cvar_t cl_name;
extern cvar_t cl_color;
extern cvar_t cl_autofire;
extern cvar_t cl_nolerp;
extern cvar_t *cl_name;
extern cvar_t *cl_color;
extern cvar_t *cl_autofire;
extern cvar_t *cl_nolerp;
#endif // UQUAKE
#ifdef QUAKEWORLD
extern cvar_t cl_warncmd;
extern cvar_t name;
extern cvar_t *cl_warncmd;
extern cvar_t *name;
#endif // QUAKEWORLD
extern cvar_t rate;
extern cvar_t host_speeds;
extern cvar_t cl_maxfps;
extern cvar_t cl_upspeed;
extern cvar_t cl_forwardspeed;
extern cvar_t cl_backspeed;
extern cvar_t cl_sidespeed;
extern cvar_t *rate;
extern cvar_t *host_speeds;
extern cvar_t *cl_maxfps;
extern cvar_t *cl_upspeed;
extern cvar_t *cl_forwardspeed;
extern cvar_t *cl_backspeed;
extern cvar_t *cl_sidespeed;
extern cvar_t cl_movespeedkey;
extern cvar_t *cl_movespeedkey;
extern cvar_t cl_yawspeed;
extern cvar_t cl_pitchspeed;
extern cvar_t *cl_yawspeed;
extern cvar_t *cl_pitchspeed;
extern cvar_t cl_anglespeedkey;
extern cvar_t *cl_anglespeedkey;
extern cvar_t cl_shownet;
extern cvar_t cl_sbar;
extern cvar_t cl_hudswap;
extern cvar_t *cl_shownet;
extern cvar_t *cl_sbar;
extern cvar_t *cl_hudswap;
extern cvar_t cl_pitchdriftspeed;
extern cvar_t lookspring;
extern cvar_t lookstrafe;
extern cvar_t sensitivity;
extern cvar_t *cl_pitchdriftspeed;
extern cvar_t *lookspring;
extern cvar_t *lookstrafe;
extern cvar_t *sensitivity;
extern cvar_t m_pitch;
extern cvar_t m_yaw;
extern cvar_t m_forward;
extern cvar_t m_side;
extern cvar_t *m_pitch;
extern cvar_t *m_yaw;
extern cvar_t *m_forward;
extern cvar_t *m_side;
extern cvar_t _windowed_mouse;
extern cvar_t *_windowed_mouse;
#define MAX_TEMP_ENTITIES 64 // lightning bolts, etc
#define MAX_STATIC_ENTITIES 128 // torches, etc

8
common/cmd.c
View file

@ -48,8 +48,8 @@ cmdalias_t *cmd_alias;
qboolean cmd_wait;
cvar_t cl_warncmd = {"cl_warncmd", "0"};
//cvar_t cl_warncmd = {"cl_warncmd", "0"};
cvar_t *cl_warncmd;
//=============================================================================
/*
@ -317,7 +317,7 @@ void Cmd_Exec_f (void)
Con_Printf ("couldn't exec %s\n",Cmd_Argv(1));
return;
}
if (!Cvar_Command () && (cl_warncmd.value || developer.value))
if (!Cvar_Command () && (cl_warncmd->value || developer->value))
Con_Printf ("execing %s\n",Cmd_Argv(1));
Cbuf_InsertText (f);
@ -734,7 +734,7 @@ void Cmd_ExecuteString (char *text, cmd_source_t src)
}
// check cvars
if (!Cvar_Command () && (cl_warncmd.value || developer.value))
if (!Cvar_Command () && (cl_warncmd->value || developer->value))
Con_Printf ("Unknown command \"%s\"\n", Cmd_Argv(0));
}

7
common/common.c
View file

@ -720,7 +720,8 @@ void COM_Init (void)
LittleFloat = FloatNoSwap;
#endif
Cvar_RegisterVariable (&cmdline);
// Cvar_RegisterVariable (&cmdline);
cmdline = Cvar_Get ("cmdline","0",CVAR_USERINFO|CVAR_SERVERINFO,"None");
Cmd_AddCommand ("path", COM_Path_f);
COM_InitFilesystem ();
@ -884,7 +885,7 @@ void Info_SetValueForStarKey (char *s, char *key, char *value, int maxsize)
char new[1024], *v;
int c;
#ifdef SERVERONLY
extern cvar_t sv_highchars;
extern cvar_t *sv_highchars;
#endif
if (strstr (key, "\\") || strstr (value, "\\") )
@ -943,7 +944,7 @@ void Info_SetValueForStarKey (char *s, char *key, char *value, int maxsize)
c = tolower(c);
}
#else
if (!sv_highchars.value) {
if (!sv_highchars->value) {
c &= 127;
if (c < 32 || c > 127)
continue;

2
common/common.h
View file

@ -156,7 +156,7 @@ char *COM_Parse (char *data);
extern int com_argc;
extern char **com_argv;
extern cvar_t cmdline;
extern cvar_t *cmdline;
int COM_CheckParm (char *parm);
void COM_AddParm (char *parm);

6
common/common_quakedef.h
View file

@ -123,9 +123,9 @@ extern qboolean noclip_anglehack;
//
extern quakeparms_t host_parms;
extern cvar_t sys_ticrate;
extern cvar_t sys_nostdout;
extern cvar_t developer;
extern cvar_t *sys_ticrate;
extern cvar_t *sys_nostdout;
extern cvar_t *developer;
extern qboolean host_initialized;// true if into command execution
extern double host_frametime;

10
common/console.c
View file

@ -46,7 +46,8 @@ int con_totallines; // total lines in console scrollback
float con_cursorspeed = 4;
cvar_t con_notifytime = {"con_notifytime","3"}; //seconds
//cvar_t con_notifytime = {"con_notifytime","3"}; //seconds
cvar_t *con_notifytime;
#define NUM_CON_TIMES 4
float con_times[NUM_CON_TIMES]; // realtime time the line was generated
@ -252,7 +253,8 @@ void Con_Init (void)
//
// register our commands
//
Cvar_RegisterVariable (&con_notifytime);
// Cvar_RegisterVariable (&con_notifytime);
con_notifytime = Cvar_Get ("con_notifytime","3",0,"None");
Cmd_AddCommand ("toggleconsole", Con_ToggleConsole_f);
Cmd_AddCommand ("togglechat", Con_ToggleChat_f);
@ -412,7 +414,7 @@ void Con_DPrintf (char *fmt, ...)
va_list argptr;
char msg[MAXPRINTMSG];
if (!developer.value)
if (!developer->value)
return; // don't confuse non-developers with techie stuff...
va_start (argptr,fmt);
@ -496,7 +498,7 @@ void Con_DrawNotify (void)
if (time == 0)
continue;
time = realtime - time;
if (time > con_notifytime.value)
if (time > con_notifytime->value)
continue;
text = con->text + (i % con_totallines)*con_linewidth;

120
common/cvar.c
View file

@ -142,16 +142,16 @@ void Cvar_Set (char *var_name, char *value)
Con_Printf ("Cvar_Set: variable %s not found\n", var_name);
return;
}
if(var->type&CVAR_ROM && !var->first) return;
if(var->flags&CVAR_ROM) return;
#ifdef SERVERONLY
if (var->type&CVAR_SERVERINFO)
if (var->flags&CVAR_SERVERINFO)
{
Info_SetValueForKey (svs.info, var_name, value, MAX_SERVERINFO_STRING);
SV_SendServerInfoChange(var_name, value);
// SV_BroadcastCommand ("fullserverinfo \"%s\"\n", svs.info);
}
#else
if (var->type&CVAR_USERINFO)
if (var->flags&CVAR_USERINFO)
{
Info_SetValueForKey (cls.userinfo, var_name, value, MAX_INFO_STRING);
if (cls.state >= ca_connected)
@ -167,7 +167,6 @@ void Cvar_Set (char *var_name, char *value)
var->string = Z_Malloc (Q_strlen(value)+1);
Q_strcpy (var->string, value);
var->value = Q_atof (var->string);
var->first = false;
}
#elif defined(UQUAKE)
void Cvar_Set (char *var_name, char *value)
@ -183,7 +182,7 @@ void Cvar_Set (char *var_name, char *value)
}
// Don't change if this is a CVAR_ROM
if(var->type&CVAR_ROM && !var->first) return;
if(var->flags&CVAR_ROM) return;
changed = Q_strcmp(var->string, value);
@ -192,66 +191,14 @@ void Cvar_Set (char *var_name, char *value)
var->string = Z_Malloc (Q_strlen(value)+1);
Q_strcpy (var->string, value);
var->value = Q_atof (var->string);
if (var->type&CVAR_NOTIFY && changed)
if (var->flags&CVAR_USERINFO && changed)
{
if (sv.active)
SV_BroadcastPrintf ("\"%s\" changed to \"%s\"\n", var->name, var->string);
}
var->first = false;
}
#endif
/*
============
Cvar_SetValue
============
*/
void Cvar_SetValue (char *var_name, float value)
{
char val[32];
snprintf(val, sizeof(val), "%f",value);
Cvar_Set (var_name, val);
}
/*
============
Cvar_RegisterVariable
Adds a freestanding variable to the variable list.
============
*/
void Cvar_RegisterVariable (cvar_t *variable)
{
char value[512];
// first check to see if it has allready been defined
if (Cvar_FindVar (variable->name))
{
Con_Printf ("Can't register variable %s, allready defined\n", variable->name);
return;
}
// check for overlap with a command
if (Cmd_Exists (variable->name))
{
Con_Printf ("Cvar_RegisterVariable: %s is a command\n", variable->name);
return;
}
// link the variable in
variable->next = cvar_vars;
cvar_vars = variable;
// copy the value off, because future sets will Z_Free it
strcpy (value, variable->string);
variable->string = Z_Malloc (1);
// set it through the function to be consistant
variable->first = true;
Cvar_Set (variable->name, value);
}
/*
============
@ -294,7 +241,7 @@ void Cvar_WriteVariables (QFile *f)
cvar_t *var;
for (var = cvar_vars ; var ; var = var->next)
if (var->type&CVAR_ARCHIVE)
if (var->flags&CVAR_ARCHIVE)
Qprintf (f, "%s \"%s\"\n", var->name, var->string);
}
@ -318,15 +265,58 @@ void Cvar_Set_f(void)
}
else
{
var = (cvar_t*)calloc(1,sizeof(cvar_t));
var->type=CVAR_USER_CREATED|CVAR_HEAP;
var->name = strdup (var_name);
var->string = value;
Cvar_RegisterVariable (var);
}
var = Cvar_Get (var_name, value, CVAR_USER_CREATED|CVAR_HEAP,
"User created cvar");
}
}
void Cvar_Init()
{
Cmd_AddCommand ("set", Cvar_Set_f);
}
void Cvar_Shutdown (void)
{
cvar_t *var,*next;
var = cvar_vars;
while(var)
{
next = var->next;
free(var->description);
free(var->string);
free(var->name);
free(var);
var = next;
}
}
cvar_t *Cvar_Get(char *name, char *string, int cvarflags, char *description)
{
cvar_t *v;
if (Cmd_Exists (name))
{
Con_Printf ("Cvar_Get: %s is a command\n",name);
return NULL;
}
v = Cvar_FindVar(name);
if (!v)
{
v = (cvar_t *) malloc(sizeof(cvar_t));
// Cvar doesn't exist, so we create it
v->next = cvar_vars;
cvar_vars = v;
v->name = strdup(name);
v->string = strdup(string);
v->flags = cvarflags;
v->description = strdup(description);
v->value = Q_atof (v->string);
return v;
}
// Cvar does exist, so we update the flags and return.
v->flags |= cvarflags;
return v;
}

16
common/cvar.h
View file

@ -63,8 +63,8 @@ typedef struct cvar_s
{
char *name;
char *string;
unsigned int type;
qboolean first; // determine if this is the first write
int flags;
char *description; // for "help" command
// qboolean archive; // set to true to cause it to be saved to vars.rc
// qboolean info; // added to serverinfo or userinfo when changed
// qboolean server; // notifies players when changed (UQUAKE)
@ -89,6 +89,10 @@ typedef struct cvar_s
#define CVAR_HEAP 256 // allocated off the heap, safe to free
#define CVAR_CHEAT 512 // can not be changed if cheats are disabled
#define CVAR_NORESTART 1024 // do not clear when a cvar_restart is issued
#define CVAR_LATCH 2048 // will only change when C code next does
// a Cvar_Get(), so it can't be changed
#define CVAR_TEMP 4906 // can be set even when cheats are
// disabled, but is not archived
// Zoid| A good CVAR_ROM example is basepath. The code should read "cvar_t
// *fs_basepath = CvarGet("fs_basepath", ".", CVAR_ROM); The user can
@ -97,16 +101,11 @@ typedef struct cvar_s
// "look, the user made fs_basepath already", uses the users value, but sets
// CVAR_ROM as per the call.
void Cvar_RegisterVariable (cvar_t *variable);
// registers a cvar that allready has the name, string, and optionally the
// archive elements set.
cvar_t *Cvar_Get (char *name, char *value, int cvarflags, char *description);
void Cvar_Set (char *var_name, char *value);
// equivelant to "<name> <variable>" typed at the console
void Cvar_SetValue (char *var_name, float value);
// expands value to a string and calls Cvar_Set
float Cvar_VariableValue (char *var_name);
// returns 0 if not defined or non numeric
@ -130,5 +129,6 @@ cvar_t *Cvar_FindVar (char *var_name);
void Cvar_Init();
void Cvar_Shutdown();
extern cvar_t *cvar_vars;
#endif // _CVAR_H

3
common/cvars.c
View file

@ -21,4 +21,5 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "quakedef.h"
cvar_t gl_flashblend = {"gl_flashblend","1"};
//cvar_t gl_flashblend = {"gl_flashblend","1"};
cvar_t *gl_flashblend;

41
common/cvars.h
View file

@ -23,26 +23,27 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#ifndef _CVARS_H
#define _CVARS_H
extern cvar_t gl_flashblend;
extern cvar_t *gl_flashblend;
/* From r_local.h */
extern cvar_t r_draworder;
extern cvar_t r_speeds;
extern cvar_t r_timegraph;
extern cvar_t r_graphheight;
extern cvar_t r_clearcolor;
extern cvar_t r_waterwarp;
extern cvar_t r_fullbright;
extern cvar_t r_drawentities;
extern cvar_t r_aliasstats;
extern cvar_t r_dspeeds;
extern cvar_t r_drawflat;
extern cvar_t r_ambient;
extern cvar_t r_reportsurfout;
extern cvar_t r_maxsurfs;
extern cvar_t r_numsurfs;
extern cvar_t r_reportedgeout;
extern cvar_t r_maxedges;
extern cvar_t r_numedges;
// From r_local.h
extern cvar_t *r_draworder;
extern cvar_t *r_speeds;
extern cvar_t *r_timegraph;
extern cvar_t *r_graphheight;
extern cvar_t *r_clearcolor;
extern cvar_t *r_waterwarp;
extern cvar_t *r_fullbright;
extern cvar_t *r_drawentities;
extern cvar_t *r_aliasstats;
extern cvar_t *r_dspeeds;
extern cvar_t *r_drawflat;
extern cvar_t *r_ambient;
extern cvar_t *r_reportsurfout;
extern cvar_t *r_maxsurfs;
extern cvar_t *r_numsurfs;
extern cvar_t *r_reportedgeout;
extern cvar_t *r_maxedges;
extern cvar_t *r_numedges;
#endif /* _CVARS_H */

2
common/d_iface.h
View file

@ -113,7 +113,7 @@ typedef struct
int color;
} zpointdesc_t;
extern cvar_t r_drawflat;
extern cvar_t *r_drawflat;
extern int d_spanpixcount;
extern int r_framecount; // sequence # of current frame since Quake
// started

24
common/d_init.c
View file

@ -27,9 +27,12 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#define NUM_MIPS 4
cvar_t d_subdiv16 = {"d_subdiv16", "1"};
cvar_t d_mipcap = {"d_mipcap", "0"};
cvar_t d_mipscale = {"d_mipscale", "1"};
//cvar_t d_subdiv16 = {"d_subdiv16", "1"};
cvar_t *d_subdiv16;
//cvar_t d_mipcap = {"d_mipcap", "0"};
cvar_t *d_mipcap;
//cvar_t d_mipscale = {"d_mipscale", "1"};
cvar_t *d_mipscale;
surfcache_t *d_initial_rover;
qboolean d_roverwrapped;
@ -53,9 +56,12 @@ void D_Init (void)
r_skydirect = 1;
Cvar_RegisterVariable (&d_subdiv16);
Cvar_RegisterVariable (&d_mipcap);
Cvar_RegisterVariable (&d_mipscale);
// Cvar_RegisterVariable (&d_subdiv16);
d_subdiv16 = Cvar_Get ("d_subdiv16","1",0,"None");
// Cvar_RegisterVariable (&d_mipcap);
d_mipcap = Cvar_Get ("d_mipcap","0",0,"None");
// Cvar_RegisterVariable (&d_mipscale);
d_mipscale = Cvar_Get ("d_mipscale","1",0,"None");
r_drawpolys = false;
r_worldpolysbacktofront = false;
@ -140,17 +146,17 @@ void D_SetupFrame (void)
d_roverwrapped = false;
d_initial_rover = sc_rover;
d_minmip = d_mipcap.value;
d_minmip = d_mipcap->value;
if (d_minmip > 3)
d_minmip = 3;
else if (d_minmip < 0)
d_minmip = 0;
for (i=0 ; i<(NUM_MIPS-1) ; i++)
d_scalemip[i] = basemip[i] * d_mipscale.value;
d_scalemip[i] = basemip[i] * d_mipscale->value;
#if id386
if (d_subdiv16.value)
if (d_subdiv16->value)
d_drawspans = D_DrawSpans16;
else
d_drawspans = D_DrawSpans8;

2
common/d_local.h
View file

@ -56,7 +56,7 @@ typedef struct sspan_s
int u, v, count;
} sspan_t;
extern cvar_t d_subdiv16;
extern cvar_t *d_subdiv16;
extern float scale_for_mip;

16
common/draw.c
View file

@ -279,13 +279,13 @@ void Draw_Pixel(int x, int y, byte color)
void Draw_Crosshair(void)
{
int x, y;
extern cvar_t crosshair, cl_crossx, cl_crossy, crosshaircolor;
extern cvar_t *crosshair, *cl_crossx, *cl_crossy, *crosshaircolor;
extern vrect_t scr_vrect;
byte c = (byte)crosshaircolor.value;
byte c = (byte)crosshaircolor->value;
if (crosshair.value == 2) {
x = scr_vrect.x + scr_vrect.width/2 + cl_crossx.value;
y = scr_vrect.y + scr_vrect.height/2 + cl_crossy.value;
if (crosshair->value == 2) {
x = scr_vrect.x + scr_vrect.width/2 + cl_crossx->value;
y = scr_vrect.y + scr_vrect.height/2 + cl_crossy->value;
// FIXME: Find a better way to do this...
Draw_Pixel(x - 1, y, c);
Draw_Pixel(x - 3, y, c);
@ -295,10 +295,10 @@ void Draw_Crosshair(void)
Draw_Pixel(x, y - 3, c);
Draw_Pixel(x, y + 1, c);
Draw_Pixel(x, y + 3, c);
} else if (crosshair.value)
} else if (crosshair->value)
Draw_Character (
scr_vrect.x + scr_vrect.width/2-4 + cl_crossx.value,
scr_vrect.y + scr_vrect.height/2-4 + cl_crossy.value,
scr_vrect.x + scr_vrect.width/2-4 + cl_crossx->value,
scr_vrect.y + scr_vrect.height/2-4 + cl_crossy->value,
'+');
}

68
common/gl_draw.c
View file

@ -33,11 +33,14 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include <lib_replace.h>
extern unsigned char d_15to8table[65536];
extern cvar_t crosshair, cl_crossx, cl_crossy, crosshaircolor;
extern cvar_t *crosshair, *cl_crossx, *cl_crossy, *crosshaircolor;
cvar_t gl_nobind = {"gl_nobind", "0"};
cvar_t gl_max_size = {"gl_max_size", "1024"};
cvar_t gl_picmip = {"gl_picmip", "0"};
//cvar_t gl_nobind = {"gl_nobind", "0"};
cvar_t *gl_nobind;
//cvar_t gl_max_size = {"gl_max_size", "1024"};
cvar_t *gl_max_size;
//cvar_t gl_picmip = {"gl_picmip", "0"};
cvar_t *gl_picmip;
byte *draw_chars; // 8*8 graphic characters
qpic_t *draw_disc;
@ -122,7 +125,7 @@ int numgltextures;
void GL_Bind (int texnum)
{
if (gl_nobind.value)
if (gl_nobind->value)
texnum = char_texture;
if (currenttexture == texnum)
return;
@ -397,9 +400,12 @@ void Draw_Init (void)
int start;
byte *ncdata;
Cvar_RegisterVariable (&gl_nobind);
Cvar_RegisterVariable (&gl_max_size);
Cvar_RegisterVariable (&gl_picmip);
// Cvar_RegisterVariable (&gl_nobind);
gl_nobind = Cvar_Get ("gl_nobind","0",0,"None");
// Cvar_RegisterVariable (&gl_max_size);
gl_max_size = Cvar_Get ("gl_max_size","1024",0,"None");
// Cvar_RegisterVariable (&gl_picmip);
gl_picmip = Cvar_Get ("gl_picmip","0",0,"None");
// 3dfx can only handle 256 wide textures
if (!Q_strncasecmp ((char *)gl_renderer, "3dfx",4) ||
@ -581,12 +587,12 @@ void Draw_Crosshair(void)
extern vrect_t scr_vrect;
unsigned char *pColor;
if (crosshair.value == 3) {
x = scr_vrect.x + scr_vrect.width/2 - 3 + cl_crossx.value;
y = scr_vrect.y + scr_vrect.height/2 - 3 + cl_crossy.value;
if (crosshair->value == 3) {
x = scr_vrect.x + scr_vrect.width/2 - 3 + cl_crossx->value;
y = scr_vrect.y + scr_vrect.height/2 - 3 + cl_crossy->value;
glTexEnvf ( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
pColor = (unsigned char *) &d_8to24table[(byte) crosshaircolor.value];
pColor = (unsigned char *) &d_8to24table[(byte) crosshaircolor->value];
glColor4ubv ( pColor );
GL_Bind (cs_texture3);
@ -604,12 +610,12 @@ void Draw_Crosshair(void)
glEnd ();
glTexEnvf ( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE );
} else if (crosshair.value == 2) {
x = scr_vrect.x + scr_vrect.width/2 - 3 + cl_crossx.value;
y = scr_vrect.y + scr_vrect.height/2 - 3 + cl_crossy.value;
} else if (crosshair->value == 2) {
x = scr_vrect.x + scr_vrect.width/2 - 3 + cl_crossx->value;
y = scr_vrect.y + scr_vrect.height/2 - 3 + cl_crossy->value;
glTexEnvf ( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
pColor = (unsigned char *) &d_8to24table[(byte) crosshaircolor.value];
pColor = (unsigned char *) &d_8to24table[(byte) crosshaircolor->value];
glColor4ubv ( pColor );
GL_Bind (cs_texture);
@ -627,9 +633,9 @@ void Draw_Crosshair(void)
glEnd ();
glTexEnvf ( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE );
} else if (crosshair.value)
Draw_Character (scr_vrect.x + scr_vrect.width/2-4 + cl_crossx.value,
scr_vrect.y + scr_vrect.height/2-4 + cl_crossy.value,
} else if (crosshair->value)
Draw_Character (scr_vrect.x + scr_vrect.width/2-4 + cl_crossx->value,
scr_vrect.y + scr_vrect.height/2-4 + cl_crossy->value,
'+');
}
@ -1137,13 +1143,13 @@ static unsigned scaled[1024*512]; // [512*256];
for (scaled_height = 1 ; scaled_height < height ; scaled_height<<=1)
;
scaled_width >>= (int)gl_picmip.value;
scaled_height >>= (int)gl_picmip.value;
scaled_width >>= (int)gl_picmip->value;
scaled_height >>= (int)gl_picmip->value;
if (scaled_width > gl_max_size.value)
scaled_width = gl_max_size.value;
if (scaled_height > gl_max_size.value)
scaled_height = gl_max_size.value;
if (scaled_width > gl_max_size->value)
scaled_width = gl_max_size->value;
if (scaled_height > gl_max_size->value)
scaled_height = gl_max_size->value;
if (scaled_width * scaled_height > sizeof(scaled)/4)
Sys_Error ("GL_LoadTexture: too big");
@ -1260,13 +1266,13 @@ void GL_Upload8_EXT (byte *data, int width, int height, qboolean mipmap, qboole
for (scaled_height = 1 ; scaled_height < height ; scaled_height<<=1)
;
scaled_width >>= (int)gl_picmip.value;
scaled_height >>= (int)gl_picmip.value;
scaled_width >>= (int)gl_picmip->value;
scaled_height >>= (int)gl_picmip->value;
if (scaled_width > gl_max_size.value)
scaled_width = gl_max_size.value;
if (scaled_height > gl_max_size.value)
scaled_height = gl_max_size.value;
if (scaled_width > gl_max_size->value)
scaled_width = gl_max_size->value;
if (scaled_height > gl_max_size->value)
scaled_height = gl_max_size->value;
if (scaled_width * scaled_height > sizeof(scaled))
Sys_Error ("GL_LoadTexture: too big");

7
common/gl_model.c
View file

@ -52,7 +52,8 @@ byte mod_novis[MAX_MAP_LEAFS/8];
model_t mod_known[MAX_MOD_KNOWN];
int mod_numknown;
cvar_t gl_subdivide_size = {"gl_subdivide_size", "128", CVAR_ARCHIVE};
//cvar_t gl_subdivide_size = {"gl_subdivide_size", "128", CVAR_ARCHIVE};
cvar_t *gl_subdivide_size;
/*
===============
@ -61,7 +62,9 @@ Mod_Init
*/
void Mod_Init (void)
{
Cvar_RegisterVariable (&gl_subdivide_size);
// Cvar_RegisterVariable (&gl_subdivide_size);
gl_subdivide_size = Cvar_Get ("gl_subdivide_size","128",CVAR_ARCHIVE,
"None");
memset (mod_novis, 0xff, sizeof(mod_novis));
}

4
common/gl_rlight.c
View file

@ -152,7 +152,7 @@ void R_RenderDlights (void)
int i;
dlight_t *l;
if (!gl_flashblend.value)
if (!gl_flashblend->value)
return;
r_dlightframecount = r_framecount + 1; // because the count hasn't
@ -243,7 +243,7 @@ void R_PushDlights (void)
int i;
dlight_t *l;
if (gl_flashblend.value)
if (gl_flashblend->value)
return;
r_dlightframecount = r_framecount + 1; // because the count hasn't

162
common/gl_rmain.c
View file

@ -85,54 +85,83 @@ texture_t *r_notexture_mip;
int d_lightstylevalue[256]; // 8.8 fraction of base light value
cvar_t r_clearcolor = {"r_clearcolor", "2"};
//cvar_t r_clearcolor = {"r_clearcolor", "2"};
cvar_t *r_clearcolor;
void R_MarkLeaves (void);
cvar_t r_norefresh = {"r_norefresh","0"};
cvar_t r_drawentities = {"r_drawentities","1"};
cvar_t r_drawviewmodel = {"r_drawviewmodel","1"};
cvar_t r_speeds = {"r_speeds","0"};
cvar_t r_fullbright = {"r_fullbright","0"};
cvar_t r_lightmap = {"r_lightmap","0"};
cvar_t r_shadows = {"r_shadows","0"};
cvar_t r_wateralpha = {"r_wateralpha","1"};
cvar_t r_dynamic = {"r_dynamic","1"};
cvar_t r_novis = {"r_novis","0"};
//cvar_t r_norefresh = {"r_norefresh","0"};
cvar_t *r_norefresh;
//cvar_t r_drawentities = {"r_drawentities","1"};
cvar_t *r_drawentities;
//cvar_t r_drawviewmodel = {"r_drawviewmodel","1"};
cvar_t *r_drawviewmodel;
//cvar_t r_speeds = {"r_speeds","0"};
cvar_t *r_speeds;
//cvar_t r_fullbright = {"r_fullbright","0"};
cvar_t *r_fullbright;
//cvar_t r_lightmap = {"r_lightmap","0"};
cvar_t *r_lightmap;
//cvar_t r_shadows = {"r_shadows","0"};
cvar_t *r_shadows;
//cvar_t r_wateralpha = {"r_wateralpha","1"};
cvar_t *r_wateralpha;
//cvar_t r_dynamic = {"r_dynamic","1"};
cvar_t *r_dynamic;
//cvar_t r_novis = {"r_novis","0"};
cvar_t *r_novis;
#ifdef QUAKEWORLD
cvar_t r_netgraph = {"r_netgraph","0"};
//cvar_t r_netgraph = {"r_netgraph","0"};
cvar_t *r_netgraph;
#endif
// All the fog code was disabled for QuakeWold
// _reduced_ visability shouldn't be considered cheating :)
cvar_t r_fog = {"r_fog", "0"};
cvar_t r_volfog = {"r_volfog", "0"};
//cvar_t r_fog = {"r_fog", "0"};
cvar_t *r_fog;
//cvar_t r_volfog = {"r_volfog", "0"};
cvar_t *r_volfog;
// Waterwarp should be completely disabled for release
// since we are too lazy to actually fix it ;)
cvar_t r_waterwarp = {"r_waterwarp", "0"};
//cvar_t r_waterwarp = {"r_waterwarp", "0"};
cvar_t *r_waterwarp;
cvar_t r_waterripple = {"r_waterripple", "0"};
//cvar_t r_waterripple = {"r_waterripple", "0"};
cvar_t *r_waterripple;
cvar_t gl_finish = {"gl_finish","0"};
cvar_t gl_clear = {"gl_clear","0"};
cvar_t gl_cull = {"gl_cull","1"};
cvar_t gl_texsort = {"gl_texsort","1"};
cvar_t gl_smoothmodels = {"gl_smoothmodels","1"};
cvar_t gl_affinemodels = {"gl_affinemodels","0"};
cvar_t gl_polyblend = {"gl_polyblend","1"};
cvar_t gl_playermip = {"gl_playermip","0"};
cvar_t gl_nocolors = {"gl_nocolors","0"};
//cvar_t gl_finish = {"gl_finish","0"};
cvar_t *gl_finish;
//cvar_t gl_clear = {"gl_clear","0"};
cvar_t *gl_clear;
//cvar_t gl_cull = {"gl_cull","1"};
cvar_t *gl_cull;
//cvar_t gl_texsort = {"gl_texsort","1"};
cvar_t *gl_texsort;
//cvar_t gl_smoothmodels = {"gl_smoothmodels","1"};
cvar_t *gl_smoothmodels;
//cvar_t gl_affinemodels = {"gl_affinemodels","0"};
cvar_t *gl_affinemodels;
//cvar_t gl_polyblend = {"gl_polyblend","1"};
cvar_t *gl_polyblend;
//cvar_t gl_playermip = {"gl_playermip","0"};
cvar_t *gl_playermip;
//cvar_t gl_nocolors = {"gl_nocolors","0"};
cvar_t *gl_nocolors;
/*
#ifdef QUAKEWORLD
cvar_t gl_keeptjunctions = {"gl_keeptjunctions","1"};
#else
cvar_t gl_keeptjunctions = {"gl_keeptjunctions","0"};
#endif
cvar_t gl_doubleeyes = {"gl_doubleeyes", "1", CVAR_ARCHIVE};
*/
cvar_t *gl_keeptjunctions;
//cvar_t gl_doubleeyes = {"gl_doubleeyes", "1", CVAR_ARCHIVE};
cvar_t *gl_doubleeyes;
extern cvar_t gl_ztrick;
extern cvar_t *gl_ztrick;
#ifdef QUAKEWORLD
extern cvar_t scr_fov;
extern cvar_t *scr_fov;
#endif
/*
R_CullBox
@ -512,7 +541,7 @@ R_DrawAliasModel (entity_t *e) {
glPushMatrix ();
R_RotateForEntity (e);
if (!strcmp (clmodel->name, "progs/eyes.mdl") && gl_doubleeyes.value) {
if (!strcmp (clmodel->name, "progs/eyes.mdl") && gl_doubleeyes->value) {
glTranslatef (paliashdr->scale_origin[0], paliashdr->scale_origin[1], paliashdr->scale_origin[2] - (22 + 8));
// double size of eyes, since they are really hard to see in gl
glScalef (paliashdr->scale[0]*2, paliashdr->scale[1]*2, paliashdr->scale[2]*2);
@ -527,7 +556,7 @@ R_DrawAliasModel (entity_t *e) {
// we can't dynamically colormap textures, so they are cached
// seperately for the players. Heads are just uncolored.
#ifdef QUAKEWORLD
if (currententity->scoreboard && !gl_nocolors.value) {
if (currententity->scoreboard && !gl_nocolors->value) {
i = currententity->scoreboard - cl.players;
if (!currententity->scoreboard->skin) {
Skin_Find(currententity->scoreboard);
@ -538,7 +567,7 @@ R_DrawAliasModel (entity_t *e) {
}
}
#else
if (currententity->colormap != vid.colormap && !gl_nocolors.value) {
if (currententity->colormap != vid.colormap && !gl_nocolors->value) {
i = currententity - cl_entities;
//if (i >= 1 && i<=cl.maxclients && !strcmp (currententity->model->name, "progs/player.mdl"))
if (i >= 1 && i<=cl.maxclients)
@ -546,11 +575,11 @@ R_DrawAliasModel (entity_t *e) {
}
#endif
if (gl_smoothmodels.value)
if (gl_smoothmodels->value)
glShadeModel (GL_SMOOTH);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
if (gl_affinemodels.value)
if (gl_affinemodels->value)
glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
R_SetupAliasFrame (currententity->frame, paliashdr);
@ -558,12 +587,12 @@ R_DrawAliasModel (entity_t *e) {
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glShadeModel (GL_FLAT);
if (gl_affinemodels.value)
if (gl_affinemodels->value)
glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glPopMatrix ();
if (r_shadows.value) {
if (r_shadows->value) {
glPushMatrix ();
R_RotateForEntity (e);
glDisable (GL_TEXTURE_2D);
@ -586,7 +615,7 @@ R_DrawEntitiesOnList ( void ) {
int i;
if (!r_drawentities.value)
if (!r_drawentities->value)
return;
// draw sprites seperately, because of alpha blending
@ -635,20 +664,20 @@ R_DrawViewModel ( void ) {
int ambientlight, shadelight;
#ifdef QUAKEWORLD
if (!r_drawviewmodel.value || !Cam_DrawViewModel())
if (!r_drawviewmodel->value || !Cam_DrawViewModel())
return;
#else
if (!r_drawviewmodel.value)
if (!r_drawviewmodel->value)
return;
if (cl_chasecam.value)
if (cl_chasecam->value)
return;
#endif
if (envmap)
return;
if (!r_drawentities.value)
if (!r_drawentities->value)
return;
#ifdef QUAKEWORLD
if (cl.stats[STAT_ITEMS] & IT_INVISIBILITY)
@ -703,7 +732,7 @@ R_DrawViewModel ( void ) {
*/
void
R_PolyBlend ( void ) {
if (!gl_polyblend.value)
if (!gl_polyblend->value)
return;
if (!v_blend[3])
return;
@ -787,10 +816,10 @@ void
R_SetupFrame ( void ) {
// don't allow cheats in multiplayer
#ifdef QUAKEWORLD
r_fullbright.value = 0;
r_lightmap.value = 0;
r_fullbright->value = 0;
r_lightmap->value = 0;
if (!atoi(Info_ValueForKey(cl.serverinfo, "watervis")))
r_wateralpha.value = 1;
r_wateralpha->value = 1;
#else
if (cl.maxclients > 1)
Cvar_Set ("r_fullbright", "0");
@ -874,8 +903,8 @@ R_SetupGL ( void ) {
glViewport (glx + x, gly + y2, w, h);
screenaspect = (float)r_refdef.vrect.width/r_refdef.vrect.height;
// yfov = 2*atan((float)r_refdef.vrect.height/r_refdef.vrect.width)*180/M_PI;
// yfov = (2.0 * tan (scr_fov.value/360*M_PI)) / screenaspect;
// yfov = 2*atan((float)r_refdef.vrect.height/r_refdef.vrect.width)*(scr_fov.value*2)/M_PI;
// yfov = (2.0 * tan (scr_fov->value/360*M_PI)) / screenaspect;
// yfov = 2*atan((float)r_refdef.vrect.height/r_refdef.vrect.width)*(scr_fov->value*2)/M_PI;
// MYgluPerspective (yfov, screenaspect, 4, 4096);
MYgluPerspective (r_refdef.fov_y, screenaspect, 4, 4096);
@ -896,7 +925,7 @@ R_SetupGL ( void ) {
/*
set drawing parms
*/
if (gl_cull.value)
if (gl_cull->value)
glEnable(GL_CULL_FACE);
else
glDisable(GL_CULL_FACE);
@ -940,19 +969,18 @@ R_RenderScene ( void ) {
R_Clear
*/
void
R_Clear ( void )
{
R_Clear ( void ) {
static int l;
if (gl_ztrick.value)
if (gl_ztrick->value)
{
static int trickframe;
if (gl_clear.value)
if (gl_clear->value)
{
if (l != (int)r_clearcolor.value)
if (l != (int)r_clearcolor->value)
{
l = (int)r_clearcolor.value;
l = (int)r_clearcolor->value;
glClearColor (host_basepal[l*3]/255.0,
host_basepal[l*3+1]/255.0,
host_basepal[l*3+2]/255.0,
@ -977,7 +1005,7 @@ R_Clear ( void )
}
else
{
if (gl_clear.value)
if (gl_clear->value)
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
else
glClear (GL_DEPTH_BUFFER_BIT);
@ -991,14 +1019,14 @@ R_Clear ( void )
}
extern int bc_texture;
extern cvar_t crosshaircolor;
extern cvar_t *crosshaircolor;
/*
void TileBC (int x, int y, int w, int h)
{
unsigned char *pColor;
glTexEnvf ( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
pColor = (unsigned char *) &d_8to24table[(byte) r_clearcolor.value];
pColor = (unsigned char *) &d_8to24table[(byte) r_clearcolor->value];
glColor4ubv ( pColor );
GL_Bind (bc_texture);
@ -1016,7 +1044,7 @@ void TileBC (int x, int y, int w, int h)
glTexEnvf ( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE );
}
*/
/*
R_RenderView
@ -1030,18 +1058,18 @@ R_RenderView ( void ) {
// Fixme: the last argument should be a cvar... r_fog_gamma
GLfloat colors[4] = {(GLfloat) 1.0, (GLfloat) 1.0, (GLfloat) 1, (GLfloat) 0.1};
if (r_norefresh.value)
if (r_norefresh->value)
return;
if (!r_worldentity.model || !cl.worldmodel)
Sys_Error ("R_RenderView: NULL worldmodel");
// if ((int)cl_sbar.value == 1)
// if ((int)cl_sbar->value == 1)
// TileBC (0, 0, vid.width, vid.height - sb_lines);
// else
// TileBC (0, 0, vid.width, vid.height);
if (r_speeds.value)
if (r_speeds->value)
{
glFinish ();
time1 = Sys_DoubleTime ();
@ -1049,7 +1077,7 @@ R_RenderView ( void ) {
c_alias_polys = 0;
}
if (gl_finish.value)
if (gl_finish->value)
glFinish ();
R_Clear ();
@ -1060,7 +1088,7 @@ R_RenderView ( void ) {
/*
// Fixme!!
// The volume fog will not work as is :)
if(r_volfog.value)
if(r_volfog->value)
{
gl_Clear(GL_STENCIL_BUFFER_BIT);
@ -1088,24 +1116,24 @@ R_RenderView ( void ) {
*/
#endif
if (r_fog.value) { // FIXME: would be nice if the user could select what fogmode... (r_fog_mode)
if (r_fog->value) { // FIXME: would be nice if the user could select what fogmode... (r_fog_mode)
glFogi (GL_FOG_MODE, GL_EXP2);
glFogfv (GL_FOG_COLOR, colors);
glFogf (GL_FOG_DENSITY, (GLfloat) r_fog.value);
glFogf (GL_FOG_DENSITY, (GLfloat) r_fog->value);
glEnable(GL_FOG);
}
R_RenderScene ();
R_DrawViewModel ();
if(!r_volfog.value) {
if(!r_volfog->value) {
R_DrawWaterSurfaces ();
}
glDisable(GL_FOG); // More fog right here :)
R_PolyBlend ();
if (r_speeds.value) {
if (r_speeds->value) {
//glFinish ();
time2 = Sys_DoubleTime ();
Con_Printf ("%3i ms %4i wpoly %4i epoly\n", (int)((time2-time1)*1000), c_brush_polys, c_alias_polys);

110
common/gl_rmisc.c
View file

@ -32,7 +32,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
extern void R_InitBubble();
extern cvar_t r_clearcolor;
extern cvar_t *r_clearcolor;
/*
==================
@ -181,55 +181,87 @@ R_Init
void R_Init (void)
{
#ifndef QUAKEWORLD
extern cvar_t gl_finish;
extern cvar_t *gl_finish;
#endif /* QUAKEWORLD */
Cmd_AddCommand ("timerefresh", R_TimeRefresh_f);
Cmd_AddCommand ("envmap", R_Envmap_f);
Cmd_AddCommand ("pointfile", R_ReadPointFile_f);
Cvar_RegisterVariable (&r_norefresh);
Cvar_RegisterVariable (&r_lightmap);
Cvar_RegisterVariable (&r_fullbright);
Cvar_RegisterVariable (&r_drawentities);
Cvar_RegisterVariable (&r_drawviewmodel);
Cvar_RegisterVariable (&r_shadows);
Cvar_RegisterVariable (&r_wateralpha);
Cvar_RegisterVariable (&r_dynamic);
Cvar_RegisterVariable (&r_novis);
Cvar_RegisterVariable (&r_speeds);
// Cvar_RegisterVariable (&r_norefresh);
r_norefresh = Cvar_Get ("r_norefresh","0",0,"None");
// Cvar_RegisterVariable (&r_lightmap);
r_lightmap = Cvar_Get ("r_lightmap","0",0,"None");
// Cvar_RegisterVariable (&r_fullbright);
r_fullbright = Cvar_Get ("r_fullbright","0",0,"None");
// Cvar_RegisterVariable (&r_drawentities);
r_drawentities = Cvar_Get ("r_drawentities","1",0,"None");
// Cvar_RegisterVariable (&r_drawviewmodel);
r_drawviewmodel = Cvar_Get ("r_drawviewmodel","1",0,"None");
// Cvar_RegisterVariable (&r_shadows);
r_shadows = Cvar_Get ("r_shadows","0",0,"None");
// Cvar_RegisterVariable (&r_wateralpha);
r_wateralpha = Cvar_Get ("r_wateralpha","1",0,"None");
// Cvar_RegisterVariable (&r_dynamic);
r_dynamic = Cvar_Get ("r_dynamic","1",0,"None");
// Cvar_RegisterVariable (&r_novis);
r_novis = Cvar_Get ("r_novis","0",0,"None");
// Cvar_RegisterVariable (&r_speeds);
r_speeds = Cvar_Get ("r_speeds","0",0,"None");
#ifdef QUAKEWORLD
Cvar_RegisterVariable (&r_netgraph);
// Cvar_RegisterVariable (&r_netgraph);
r_netgraph = Cvar_Get ("r_netgraph","0",0,"None");
#endif /* QUAKEWORLD */
Cvar_RegisterVariable (&r_fog);
Cvar_RegisterVariable (&r_waterwarp);
// Cvar_RegisterVariable (&r_fog);
r_fog = Cvar_Get ("r_fog","0",0,"None");
// Cvar_RegisterVariable (&r_waterwarp);
r_waterwarp = Cvar_Get ("r_waterwarp","0",0,"None");
#ifdef _EXPERIMENTAL_
Cvar_RegisterVariable (&r_volfog);
// Cvar_RegisterVariable (&r_volfog);
r_volfog = Cvar_Get ("r_volfog","0",0,"None");
#endif
Cvar_RegisterVariable (&r_waterripple);
Cvar_RegisterVariable (&r_clearcolor);
// Cvar_RegisterVariable (&r_waterripple);
r_waterripple = Cvar_Get ("r_waterripple","0",0,"None");
// Cvar_RegisterVariable (&r_clearcolor);
r_clearcolor = Cvar_Get ("r_clearcolor","2",0,"None");
Cvar_RegisterVariable (&gl_clear);
Cvar_RegisterVariable (&gl_texsort);
// Cvar_RegisterVariable (&gl_clear);
gl_clear = Cvar_Get ("gl_clear","0",0,"None");
// Cvar_RegisterVariable (&gl_texsort);
gl_texsort = Cvar_Get ("gl_texsort","1",0,"None");
if (gl_mtexable)
Cvar_SetValue ("gl_texsort", 0.0);
gl_texsort->value = 0.0;
Cvar_RegisterVariable (&gl_cull);
Cvar_RegisterVariable (&gl_smoothmodels);
Cvar_RegisterVariable (&gl_affinemodels);
Cvar_RegisterVariable (&gl_polyblend);
Cvar_RegisterVariable (&gl_flashblend);
Cvar_RegisterVariable (&gl_playermip);
Cvar_RegisterVariable (&gl_nocolors);
Cvar_RegisterVariable (&gl_finish);
// Cvar_RegisterVariable (&gl_cull);
gl_cull = Cvar_Get ("gl_cull","1",0,"None");
// Cvar_RegisterVariable (&gl_smoothmodels);
gl_smoothmodels = Cvar_Get ("gl_smoothmodels","1",0,"None");
// Cvar_RegisterVariable (&gl_affinemodels);
gl_affinemodels = Cvar_Get ("gl_affinemodels","0",0,"None");
// Cvar_RegisterVariable (&gl_polyblend);
gl_polyblend = Cvar_Get ("gl_polyblend","1",0,"None");
// Cvar_RegisterVariable (&gl_flashblend);
gl_flashblend = Cvar_Get ("gl_flashblend","1",0,"None");
// Cvar_RegisterVariable (&gl_playermip);
gl_playermip = Cvar_Get ("gl_playermip","0",0,"None");
// Cvar_RegisterVariable (&gl_nocolors);
gl_nocolors = Cvar_Get ("gl_nocolors","0",0,"None");
// Cvar_RegisterVariable (&gl_finish);
gl_finish = Cvar_Get ("gl_finish","0",0,"None");
Cvar_RegisterVariable (&gl_keeptjunctions);
// Cvar_RegisterVariable (&gl_keeptjunctions);
#ifdef QUAKEWORLD
gl_keeptjunctions = Cvar_Get ("gl_keeptjunctions","1",0,"None");
#else
gl_keeptjunctions = Cvar_Get ("gl_keeptjunctions","0",0,"None");
#endif
R_InitBubble();
#ifdef UQUAKE
Cvar_RegisterVariable (&gl_doubleeyes);
// Cvar_RegisterVariable (&gl_doubleeyes);
gl_doubleeyes = Cvar_Get ("gl_doubleeyes","1",CVAR_ARCHIVE,"None");
#endif /* QUAKEWORLD */
R_InitParticles ();
@ -358,11 +390,11 @@ void R_TranslatePlayerSkin (int playernum)
false, false, true);
#endif
scaled_width = gl_max_size.value < 512 ? gl_max_size.value : 512;
scaled_height = gl_max_size.value < 256 ? gl_max_size.value : 256;
scaled_width = gl_max_size->value < 512 ? gl_max_size->value : 512;
scaled_height = gl_max_size->value < 256 ? gl_max_size->value : 256;
// allow users to crunch sizes down even more if they want
scaled_width >>= (int)gl_playermip.value;
scaled_height >>= (int)gl_playermip.value;
scaled_width >>= (int)gl_playermip->value;
scaled_height >>= (int)gl_playermip->value;
if (VID_Is8bit()) { // 8bit texture upload
byte *out2;
@ -499,12 +531,12 @@ void R_TranslatePlayerSkin (int playernum)
// don't mipmap these, because it takes too long
GL_Upload8 (translated, paliashdr->skinwidth, paliashdr->skinheight, false, false, true);
#else
scaled_width = gl_max_size.value < 512 ? gl_max_size.value : 512;
scaled_height = gl_max_size.value < 256 ? gl_max_size.value : 256;
scaled_width = gl_max_size->value < 512 ? gl_max_size->value : 512;
scaled_height = gl_max_size->value < 256 ? gl_max_size->value : 256;
// allow users to crunch sizes down even more if they want
scaled_width >>= (int)gl_playermip.value;
scaled_height >>= (int)gl_playermip.value;
scaled_width >>= (int)gl_playermip->value;
scaled_height >>= (int)gl_playermip->value;
if (VID_Is8bit()) { // 8bit texture upload
byte *out2;

4
common/gl_rpart.c
View file

@ -36,7 +36,7 @@ extern int ramp1[8], ramp2[8], ramp3[8];
R_DrawParticles
===============
*/
extern cvar_t sv_gravity;
extern cvar_t *sv_gravity;
void R_DrawParticles (void)
{
@ -73,7 +73,7 @@ void R_DrawParticles (void)
time2 = frametime * 10; // 15;
time1 = frametime * 5;
#ifdef UQUAKE
grav = frametime * sv_gravity.value * 0.05;
grav = frametime * sv_gravity->value * 0.05;
#else
grav = frametime * 800 * 0.05;
#endif

56
common/gl_rsurf.c
View file

@ -159,7 +159,7 @@ void R_BuildLightMap (msurface_t *surf, byte *dest, int stride)
lightmap = surf->samples;
// set to full bright if no light data
if (/* r_fullbright.value || */ !cl.worldmodel->lightdata)
if (/* r_fullbright->value || */ !cl.worldmodel->lightdata)
{
for (i=0 ; i<size ; i++)
blocklights[i] = 255*256;
@ -677,10 +677,10 @@ void R_BlendLightmaps (void)
glRect_t *theRect;
#if 0
if (r_fullbright.value)
if (r_fullbright->value)
return;
#endif
if (!gl_texsort.value)
if (!gl_texsort->value)
return;
glDepthMask (0); // don't bother writing Z
@ -694,7 +694,7 @@ void R_BlendLightmaps (void)
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
if (!r_lightmap.value)
if (!r_lightmap->value)
{
glEnable (GL_BLEND);
}
@ -730,9 +730,9 @@ void R_BlendLightmaps (void)
for ( ; p ; p=p->chain)
{
if (r_waterwarp.value && (p->flags & SURF_UNDERWATER)) {
if (r_waterwarp->value && (p->flags & SURF_UNDERWATER)) {
DrawGLWaterPolyLightmap (p);
// if (r_waterwarp.value && ((r_viewleaf->contents==CONTENTS_EMPTY && (p->flags & SURF_UNDERWATER)))
// if (r_waterwarp->value && ((r_viewleaf->contents==CONTENTS_EMPTY && (p->flags & SURF_UNDERWATER)))
// && !(p->flags & SURF_DONTWARP)) {
DrawGLWaterPolyLightmap (p);
}
@ -792,7 +792,7 @@ void R_RenderBrushPoly (msurface_t *fa)
return;
}
if (r_waterwarp.value&&(fa->flags & SURF_UNDERWATER))
if (r_waterwarp->value&&(fa->flags & SURF_UNDERWATER))
DrawGLWaterPoly (fa->polys);
else
DrawGLPoly (fa->polys);
@ -812,7 +812,7 @@ void R_RenderBrushPoly (msurface_t *fa)
|| fa->cached_dlight) // dynamic previously
{
dynamic:
if (r_dynamic.value)
if (r_dynamic->value)
{
lightmap_modified[fa->lightmaptexturenum] = true;
theRect = &lightmap_rectchange[fa->lightmaptexturenum];
@ -870,7 +870,7 @@ void R_RenderDynamicLightmaps (msurface_t *fa)
|| fa->cached_dlight) // dynamic previously
{
dynamic:
if (r_dynamic.value)
if (r_dynamic->value)
{
lightmap_modified[fa->lightmaptexturenum] = true;
theRect = &lightmap_rectchange[fa->lightmaptexturenum];
@ -909,7 +909,7 @@ void R_DrawWaterSurfaces (void)
msurface_t *s;
texture_t *t;
if (r_wateralpha.value == 1.0)
if (r_wateralpha->value == 1.0)
return;
//
@ -918,7 +918,7 @@ void R_DrawWaterSurfaces (void)
glLoadMatrixf (r_world_matrix);
glEnable (GL_BLEND);
glColor4f (1,1,1,r_wateralpha.value);
glColor4f (1,1,1,r_wateralpha->value);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
for (i=0 ; i<cl.worldmodel->numtextures ; i++)
@ -958,7 +958,7 @@ void R_DrawWaterSurfaces (void)
msurface_t *s;
texture_t *t;
if (r_wateralpha.value == 1.0 && gl_texsort.value)
if (r_wateralpha->value == 1.0 && gl_texsort->value)
return;
//
@ -967,13 +967,13 @@ void R_DrawWaterSurfaces (void)
glLoadMatrixf (r_world_matrix);
if (r_wateralpha.value < 1.0) {
if (r_wateralpha->value < 1.0) {
glEnable (GL_BLEND);
glColor4f (1,1,1,r_wateralpha.value);
glColor4f (1,1,1,r_wateralpha->value);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
}
if (!gl_texsort.value) {
if (!gl_texsort->value) {
if (!waterchain)
return;
@ -1008,7 +1008,7 @@ void R_DrawWaterSurfaces (void)
}
if (r_wateralpha.value < 1.0) {
if (r_wateralpha->value < 1.0) {
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glColor4f (1,1,1,1);
@ -1030,7 +1030,7 @@ void DrawTextureChains (void)
msurface_t *s;
texture_t *t;
if (!gl_texsort.value) {
if (!gl_texsort->value) {
GL_DisableMultitexture();
if (skychain) {
@ -1054,7 +1054,7 @@ void DrawTextureChains (void)
else
{
if ((s->flags & SURF_DRAWTURB) &&
r_wateralpha.value != 1.0)
r_wateralpha->value != 1.0)
continue; // draw translucent water later
for ( ; s ; s=s->texturechain)
R_RenderBrushPoly (s);
@ -1124,7 +1124,7 @@ void R_DrawBrushModel (entity_t *e)
// calculate dynamic lighting for bmodel if it's not an
// instanced model
if (clmodel->firstmodelsurface != 0 && !gl_flashblend.value)
if (clmodel->firstmodelsurface != 0 && !gl_flashblend->value)
{
for (k=0 ; k<MAX_DLIGHTS ; k++)
{
@ -1156,7 +1156,7 @@ e->angles[0] = -e->angles[0]; // stupid quake bug
if (((psurf->flags & SURF_PLANEBACK) && (dot < -BACKFACE_EPSILON)) ||
(!(psurf->flags & SURF_PLANEBACK) && (dot > BACKFACE_EPSILON)))
{
if (gl_texsort.value)
if (gl_texsort->value)
R_RenderBrushPoly (psurf);
else
R_DrawSequentialPoly (psurf);
@ -1268,17 +1268,17 @@ void R_RecursiveWorldNode (mnode_t *node)
continue;
// don't backface underwater surfaces, because they warp
if (r_waterwarp.value && !(surf->flags & SURF_UNDERWATER) && ( (dot < 0) ^ !!(surf->flags & SURF_PLANEBACK)) )
if (r_waterwarp->value && !(surf->flags & SURF_UNDERWATER) && ( (dot < 0) ^ !!(surf->flags & SURF_PLANEBACK)) )
continue; // wrong side
/* if (r_waterwarp.value && !(((r_viewleaf->contents==CONTENTS_EMPTY && (surf->flags & SURF_UNDERWATER)) ||
/* if (r_waterwarp->value && !(((r_viewleaf->contents==CONTENTS_EMPTY && (surf->flags & SURF_UNDERWATER)) ||
(r_viewleaf->contents!=CONTENTS_EMPTY && !(surf->flags & SURF_UNDERWATER)))
&& !(surf->flags & SURF_DONTWARP)) && ( (dot < 0) ^ !!(surf->flags & SURF_PLANEBACK)) )
continue; // wrong side
*/
// if sorting by texture, just store it out
if (gl_texsort.value)
if (gl_texsort->value)
{
surf->texturechain = surf->texinfo->texture->texturechain;
surf->texinfo->texture->texturechain = surf;
@ -1349,13 +1349,13 @@ void R_MarkLeaves (void)
int i;
byte solid[4096];
if (r_oldviewleaf == r_viewleaf && !r_novis.value)
if (r_oldviewleaf == r_viewleaf && !r_novis->value)
return;
r_visframecount++;
r_oldviewleaf = r_viewleaf;
if (r_novis.value)
if (r_novis->value)
{
vis = solid;
memset (solid, 0xff, (cl.worldmodel->numleafs+7)>>3);
@ -1511,7 +1511,7 @@ void BuildSurfaceDisplayList (msurface_t *fa)
//
// remove co-linear points - Ed
//
if (!gl_keeptjunctions.value && !(fa->flags & SURF_UNDERWATER) )
if (!gl_keeptjunctions->value && !(fa->flags & SURF_UNDERWATER) )
{
for (i = 0 ; i < lnumverts ; ++i)
{
@ -1646,7 +1646,7 @@ void GL_BuildLightmaps (void)
}
}
if (!gl_texsort.value)
if (!gl_texsort->value)
GL_SelectTexture(TEXTURE1_SGIS);
//
@ -1669,7 +1669,7 @@ void GL_BuildLightmaps (void)
gl_lightmap_format, GL_UNSIGNED_BYTE, lightmaps+i*BLOCK_WIDTH*BLOCK_HEIGHT*lightmap_bytes);
}
if (!gl_texsort.value)
if (!gl_texsort->value)
GL_SelectTexture(TEXTURE0_SGIS);
}

122
common/gl_screen.c
View file

@ -100,17 +100,27 @@ float scr_con_current;
float scr_conlines; // lines of console to display
float oldscreensize, oldfov;
cvar_t scr_viewsize = {"viewsize","100", CVAR_ARCHIVE};
cvar_t scr_fov = {"fov","90"}; // 10 - 170
cvar_t scr_conspeed = {"scr_conspeed","300"};
cvar_t scr_centertime = {"scr_centertime","2"};
cvar_t scr_showram = {"showram","1"};
cvar_t scr_showturtle = {"showturtle","0"};
cvar_t scr_showpause = {"showpause","1"};
cvar_t scr_printspeed = {"scr_printspeed","8"};
cvar_t scr_allowsnap = {"scr_allowsnap", "1"};
cvar_t gl_triplebuffer = {"gl_triplebuffer", "1", CVAR_ARCHIVE };
extern cvar_t crosshair;
//cvar_t scr_viewsize = {"viewsize","100", CVAR_ARCHIVE};
cvar_t *scr_viewsize;
//cvar_t scr_fov = {"fov","90"}; // 10 - 170
cvar_t *scr_fov;
//cvar_t scr_conspeed = {"scr_conspeed","300"};
cvar_t *scr_conspeed;
//cvar_t scr_centertime = {"scr_centertime","2"};
cvar_t *scr_centertime;
//cvar_t scr_showram = {"showram","1"};
cvar_t *scr_showram;
//cvar_t scr_showturtle = {"showturtle","0"};
cvar_t *scr_showturtle;
//cvar_t scr_showpause = {"showpause","1"};
cvar_t *scr_showpause;
//cvar_t scr_printspeed = {"scr_printspeed","8"};
cvar_t *scr_printspeed;
//cvar_t scr_allowsnap = {"scr_allowsnap", "1"};
cvar_t *scr_allowsnap;
//cvar_t gl_triplebuffer = {"gl_triplebuffer", "1", CVAR_ARCHIVE };
cvar_t *gl_triplebuffer;
extern cvar_t *crosshair;
qboolean scr_initialized; // ready to draw
@ -164,7 +174,7 @@ for a few moments
void SCR_CenterPrint (char *str)
{
strncpy (scr_centerstring, str, sizeof(scr_centerstring)-1);
scr_centertime_off = scr_centertime.value;
scr_centertime_off = scr_centertime->value;
scr_centertime_start = cl.time;
// count the number of lines for centering
@ -188,7 +198,7 @@ void SCR_DrawCenterString (void)
// the finale prints the characters one at a time
if (cl.intermission)
remaining = scr_printspeed.value * (cl.time - scr_centertime_start);
remaining = scr_printspeed->value * (cl.time - scr_centertime_start);
else
remaining = 9999;
@ -289,22 +299,22 @@ static void SCR_CalcRefdef (void)
//========================================
// bound viewsize
if (scr_viewsize.value < 30)
if (scr_viewsize->value < 30)
Cvar_Set ("viewsize","30");
if (scr_viewsize.value > 120)
if (scr_viewsize->value > 120)
Cvar_Set ("viewsize","120");
// bound field of view
if (scr_fov.value < 10)
if (scr_fov->value < 10)
Cvar_Set ("fov","10");
if (scr_fov.value > 170)
if (scr_fov->value > 170)
Cvar_Set ("fov","170");
// intermission is always full screen
if (cl.intermission)
size = 120;
else
size = scr_viewsize.value;
size = scr_viewsize->value;
if (size >= 120)
sb_lines = 0; // no status bar at all
@ -313,11 +323,11 @@ static void SCR_CalcRefdef (void)
else
sb_lines = 24+16+8;
if (scr_viewsize.value >= 100.0) {
if (scr_viewsize->value >= 100.0) {
full = true;
size = 100.0;
} else
size = scr_viewsize.value;
size = scr_viewsize->value;
if (cl.intermission)
{
full = true;
@ -326,7 +336,7 @@ static void SCR_CalcRefdef (void)
}
size /= 100.0;
if (!cl_sbar.value && full)
if (!cl_sbar->value && full)
h = vid.height;
else
h = vid.height - sb_lines;
@ -339,7 +349,7 @@ static void SCR_CalcRefdef (void)
}
r_refdef.vrect.height = vid.height * size;
if (cl_sbar.value || !full) {
if (cl_sbar->value || !full) {
if (r_refdef.vrect.height > vid.height - sb_lines)
r_refdef.vrect.height = vid.height - sb_lines;
} else if (r_refdef.vrect.height > vid.height)
@ -350,7 +360,7 @@ static void SCR_CalcRefdef (void)
else
r_refdef.vrect.y = (h - r_refdef.vrect.height)/2;
r_refdef.fov_x = scr_fov.value;
r_refdef.fov_x = scr_fov->value;
r_refdef.fov_y = CalcFov (r_refdef.fov_x, r_refdef.vrect.width, r_refdef.vrect.height);
scr_vrect = r_refdef.vrect;
@ -366,7 +376,7 @@ Keybinding command
*/
void SCR_SizeUp_f (void)
{
Cvar_SetValue ("viewsize",scr_viewsize.value+10);
scr_viewsize->value = scr_viewsize->value+10;
vid.recalc_refdef = 1;
}
@ -380,7 +390,7 @@ Keybinding command
*/
void SCR_SizeDown_f (void)
{
Cvar_SetValue ("viewsize",scr_viewsize.value-10);
scr_viewsize->value = scr_viewsize->value-10;
vid.recalc_refdef = 1;
}
@ -393,16 +403,26 @@ SCR_Init
*/
void SCR_Init (void)
{
Cvar_RegisterVariable (&scr_fov);
Cvar_RegisterVariable (&scr_viewsize);
Cvar_RegisterVariable (&scr_conspeed);
Cvar_RegisterVariable (&scr_showram);
Cvar_RegisterVariable (&scr_showturtle);
Cvar_RegisterVariable (&scr_showpause);
Cvar_RegisterVariable (&scr_centertime);
Cvar_RegisterVariable (&scr_printspeed);
Cvar_RegisterVariable (&scr_allowsnap);
Cvar_RegisterVariable (&gl_triplebuffer);
// Cvar_RegisterVariable (&scr_fov);
scr_fov = Cvar_Get ("fov","90",0,"None");
// Cvar_RegisterVariable (&scr_viewsize);
scr_viewsize = Cvar_Get ("viewsize","100",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&scr_conspeed);
scr_conspeed = Cvar_Get ("scr_conspeed","300",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&scr_showram);
scr_showram = Cvar_Get ("scr_showram","1",0,"None");
// Cvar_RegisterVariable (&scr_showturtle);
scr_showturtle = Cvar_Get ("scr_showturtle","0",0,"None");
// Cvar_RegisterVariable (&scr_showpause);
scr_showpause = Cvar_Get ("scr_showpause","1",0,"None");
// Cvar_RegisterVariable (&scr_centertime);
scr_centertime = Cvar_Get ("scr_centertime","2",0,"None");
// Cvar_RegisterVariable (&scr_printspeed);
scr_printspeed = Cvar_Get ("scr_printspeed","8",0,"None");
// Cvar_RegisterVariable (&scr_allowsnap);
scr_allowsnap = Cvar_Get ("scr_allowsnap","1",0,"None");
// Cvar_RegisterVariable (&gl_triplebuffer);
gl_triplebuffer = Cvar_Get ("gl_triplebuffer","1",CVAR_ARCHIVE,"None");
//
// register our commands
@ -428,7 +448,7 @@ SCR_DrawRam
*/
void SCR_DrawRam (void)
{
if (!scr_showram.value)
if (!scr_showram->value)
return;
if (!r_cache_thrash)
@ -446,7 +466,7 @@ void SCR_DrawTurtle (void)
{
static int count;
if (!scr_showturtle.value)
if (!scr_showturtle->value)
return;
if (host_frametime < 0.1)
@ -491,7 +511,7 @@ quakeworld client
*/
void SCR_DrawFPS (void)
{
extern cvar_t show_fps;
extern cvar_t *show_fps;
static double lastframetime;
double t;
extern int fps_count;
@ -499,7 +519,7 @@ void SCR_DrawFPS (void)
int x, y;
char st[80];
if (!show_fps.value)
if (!show_fps->value)
return;
t = Sys_DoubleTime();
@ -526,7 +546,7 @@ void SCR_DrawPause (void)
{
qpic_t *pic;
if (!scr_showpause.value) // turn off for screenshots
if (!scr_showpause->value) // turn off for screenshots
return;
if (!cl.paused)
@ -586,14 +606,14 @@ void SCR_SetUpToDrawConsole (void)
if (scr_conlines < scr_con_current)
{
scr_con_current -= scr_conspeed.value * host_frametime * 4;
scr_con_current -= scr_conspeed->value * host_frametime * 4;
if (scr_conlines > scr_con_current)
scr_con_current = scr_conlines;
}
else if (scr_conlines > scr_con_current)
{
scr_con_current += scr_conspeed.value * host_frametime * 4;
scr_con_current += scr_conspeed->value * host_frametime * 4;
if (scr_conlines < scr_con_current)
scr_con_current = scr_conlines;
}
@ -969,9 +989,9 @@ void SCR_RSShot_f (void)
st[sizeof(st) - 1] = 0;
SCR_DrawStringToSnap (st, newbuf, w - strlen(st)*8, h - 11, w);
#ifdef QUAKEWORLD
strncpy(st, name.string, sizeof(st));
strncpy(st, name->string, sizeof(st));
#else
strncpy(st, cl_name.string, sizeof(st));
strncpy(st, cl_name->string, sizeof(st));
#endif
st[sizeof(st) - 1] = 0;
SCR_DrawStringToSnap (st, newbuf, w - strlen(st)*8, h - 21, w);
@ -1171,7 +1191,7 @@ void SCR_UpdateScreen (void)
if (block_drawing)
return;
vid.numpages = 2 + gl_triplebuffer.value;
vid.numpages = 2 + gl_triplebuffer->value;
scr_copytop = 0;
scr_copyeverything = 0;
@ -1191,8 +1211,8 @@ void SCR_UpdateScreen (void)
return; // not initialized yet
if (oldsbar != cl_sbar.value) {
oldsbar = cl_sbar.value;
if (oldsbar != cl_sbar->value) {
oldsbar = cl_sbar->value;
vid.recalc_refdef = true;
}
@ -1201,9 +1221,9 @@ void SCR_UpdateScreen (void)
//
// determine size of refresh window
//
if (oldfov != scr_fov.value)
if (oldfov != scr_fov->value)
{
oldfov = scr_fov.value;
oldfov = scr_fov->value;
vid.recalc_refdef = true;
}
@ -1224,7 +1244,7 @@ void SCR_UpdateScreen (void)
//
SCR_TileClear ();
#ifdef QUAKEWORLD
if (r_netgraph.value)
if (r_netgraph->value)
R_NetGraph ();
#endif
@ -1251,7 +1271,7 @@ void SCR_UpdateScreen (void)
}
else
{
if (crosshair.value)
if (crosshair->value)
Draw_Crosshair();
SCR_DrawRam ();

31
common/gl_vidglx.c
View file

@ -82,13 +82,16 @@ unsigned short d_8to16table[256];
unsigned d_8to24table[256];
unsigned char d_15to8table[65536];
cvar_t vid_mode = {"vid_mode", "0", CVAR_NONE};
cvar_t vid_glx_fullscreen = {"vid_glx_fullscreen", "0", CVAR_NONE};
//cvar_t vid_mode = {"vid_mode", "0", CVAR_NONE};
cvar_t *vid_mode;
//cvar_t vid_glx_fullscreen = {"vid_glx_fullscreen", "0", CVAR_NONE};
cvar_t *vid_glx_fullscreen;
#ifdef HAS_DGA
static int nummodes;
static XF86VidModeModeInfo **vidmodes;
static int hasdgavideo = 0, hasvidmode = 0;
#endif
#ifdef HAVE_DLOPEN
@ -119,7 +122,8 @@ int texture_extension_number = 1;
float gldepthmin, gldepthmax;
cvar_t gl_ztrick = {"gl_ztrick", "0", CVAR_ARCHIVE};
//cvar_t gl_ztrick = {"gl_ztrick", "0", CVAR_ARCHIVE};
cvar_t *gl_ztrick;
const char *gl_vendor;
const char *gl_renderer;
@ -410,10 +414,19 @@ void VID_Init(unsigned char *palette)
S_Init();
Cvar_RegisterVariable(&vid_mode);
Cvar_RegisterVariable(&gl_ztrick);
Cvar_RegisterVariable(&vid_glx_fullscreen);
// Cvar_RegisterVariable(&vid_mode);
vid_mode = Cvar_Get ("vid_mode","0",0,"None");
// Cvar_RegisterVariable(&gl_ztrick);
gl_ztrick = Cvar_Get ("gl_ztrick","0",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable(&_windowed_mouse);
_windowed_mouse = Cvar_Get ("_windowed_mouse","0",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable(&vid_glx_fullscreen);
vid_glx_fullscreen = Cvar_Get ("vid_glx_fullscreen","0",0,"None");
#ifdef HAS_DGA
// Cvar_RegisterVariable(&vid_dga_mouseaccel);
vid_dga_mouseaccel = Cvar_Get("vid_dga_mouseaccel","1",CVAR_ARCHIVE,
"None");
#endif
vid.maxwarpwidth = WARP_WIDTH;
vid.maxwarpheight = WARP_HEIGHT;
vid.colormap = host_colormap;
@ -499,9 +512,9 @@ void VID_Init(unsigned char *palette)
const char *str = getenv("MESA_GLX_FX");
if (str != NULL && *str != 'f') {
if (tolower(*str) == 'w') {
Cvar_SetValue("vid_glx_fullscreen", 0);
vid_glx_fullscreen->value = 0;
} else {
Cvar_SetValue("vid_glx_fullscreen", 1);
vid_glx_fullscreen->value = 1;
}
}
#endif

25
common/gl_vidlinux_3dfx.c
View file

@ -47,10 +47,14 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
unsigned d_8to24table[256];
unsigned char d_15to8table[65536];
static cvar_t vid_mode = {"vid_mode", "5", CVAR_NONE};
static cvar_t vid_redrawfull = {"vid_redrawfull", "0", CVAR_NONE};
static cvar_t vid_waitforrefresh = {"vid_waitforrefresh", "0", CVAR_ARCHIVE};
cvar_t gl_ztrick = {"gl_ztrick", "0", CVAR_ARCHIVE};
//static cvar_t vid_mode = {"vid_mode", "5", CVAR_NONE};
static cvar_t *vid_mode;
//static cvar_t vid_redrawfull = {"vid_redrawfull", "0", CVAR_NONE};
static cvar_t *vid_redrawfull;
//static cvar_t vid_waitforrefresh = {"vid_waitforrefresh", "0", CVAR_ARCHIVE};
static cvar_t *vid_waitforrefresh;
//cvar_t gl_ztrick = {"gl_ztrick", "0", CVAR_ARCHIVE};
cvar_t *gl_ztrick;
static fxMesaContext fc = NULL;
static int scr_width, scr_height;
@ -410,10 +414,15 @@ void VID_Init(unsigned char *palette)
S_Init();
Cvar_RegisterVariable (&vid_mode);
Cvar_RegisterVariable (&vid_redrawfull);
Cvar_RegisterVariable (&vid_waitforrefresh);
Cvar_RegisterVariable (&gl_ztrick);
// Cvar_RegisterVariable (&vid_mode);
vid_mode = Cvar_Get ("vid_mode","5",0,"None");
// Cvar_RegisterVariable (&vid_redrawfull);
vid_redrawfull = Cvar_Get ("vid_redrawfull","0",0,"None");
// Cvar_RegisterVariable (&vid_waitforrefresh);
vid_waitforrefresh = Cvar_Get ("vid_waitforrefresh","0",CVAR_ARCHIVE,
"None");
// Cvar_RegisterVariable (&gl_ztrick);
gl_ztrick = Cvar_Get ("gl_ztrick","0",CVAR_ARCHIVE,"None");
vid.maxwarpwidth = WARP_WIDTH;
vid.maxwarpheight = WARP_HEIGHT;

69
common/gl_vidnt.c
View file

@ -149,12 +149,33 @@ qboolean gl_mtexable = false;
//====================================
cvar_t gl_ztrick = {"gl_ztrick", "1", CVAR_ARCHIVE};
//cvar_t gl_ztrick = {"gl_ztrick", "1", CVAR_ARCHIVE};
cvar_t *gl_ztrick;
cvar_t vid_mode = {"vid_mode", "0", CVAR_NONE};
//cvar_t vid_mode = {"vid_mode", "0", CVAR_NONE};
cvar_t *vid_mode;
// Note that 0 is MODE_WINDOWED
cvar_t _vid_default_mode = {"_vid_default_mode", "0", CVAR_ARCHIVE};
//cvar_t _vid_default_mode = {"_vid_default_mode", "0", CVAR_ARCHIVE};
cvar_t *_vid_default_mode;
// Note that 3 is MODE_FULLSCREEN_DEFAULT
<<<<<<< gl_vidnt.c
//cvar_t _vid_default_mode_win = {"_vid_default_mode_win", "3", CVAR_ARCHIVE};
cvar_t *_vid_default_mode_win;
//cvar_t vid_wait = {"vid_wait", "0"};
cvar_t *vid_wait;
//cvar_t vid_nopageflip = {"vid_nopageflip", "0", CVAR_ARCHIVE};
cvar_t *vid_nopageflip;
//cvar_t _vid_wait_override = {"_vid_wait_override", "0", CVAR_ARCHIVE};
cvar_t *_vid_wait_override;
//cvar_t vid_config_x = {"vid_config_x", "800", CVAR_ARCHIVE};
cvar_t *vid_config_x;
//cvar_t vid_config_y = {"vid_config_y", "600", CVAR_ARCHIVE};
cvar_t *vid_config_y;
//cvar_t vid_stretch_by_2 = {"vid_stretch_by_2", "1", CVAR_ARCHIVE};
cvar_t *vid_stretch_by_2;
//cvar_t _windowed_mouse = {"_windowed_mouse", "1", CVAR_ARCHIVE};
cvar_t *_windowed_mouse;
=======
cvar_t _vid_default_mode_win = {"_vid_default_mode_win", "3", CVAR_ARCHIVE};
cvar_t vid_wait = {"vid_wait", "0"};
cvar_t vid_nopageflip = {"vid_nopageflip", "0", CVAR_ARCHIVE};
@ -162,6 +183,7 @@ cvar_t _vid_wait_override = {"_vid_wait_override", "0", CVAR_ARCHIVE};
cvar_t vid_config_x = {"vid_config_x", "800", CVAR_ARCHIVE};
cvar_t vid_config_y = {"vid_config_y", "600", CVAR_ARCHIVE};
cvar_t vid_stretch_by_2 = {"vid_stretch_by_2", "1", CVAR_ARCHIVE};
>>>>>>> 1.20
int window_center_x, window_center_y, window_x, window_y, window_width, window_height;
RECT window_rect;
@ -400,7 +422,7 @@ int VID_SetMode (int modenum, unsigned char *palette)
// Set either the fullscreen or windowed mode
if (modelist[modenum].type == MS_WINDOWED)
{
if (_windowed_mouse.value && key_dest == key_game)
if (_windowed_mouse->value && key_dest == key_game)
{
stat = VID_SetWindowedMode(modenum);
IN_ActivateMouse ();
@ -660,7 +682,7 @@ GL_BeginRendering
*/
void GL_BeginRendering (int *x, int *y, int *width, int *height)
{
extern cvar_t gl_clear;
extern cvar_t *gl_clear;
*x = *y = 0;
*width = WindowRect.right - WindowRect.left;
@ -681,7 +703,7 @@ void GL_EndRendering (void)
// handle the mouse state when windowed if that's changed
if (modestate == MS_WINDOWED)
{
if (!_windowed_mouse.value) {
if (!_windowed_mouse->value) {
if (windowed_mouse) {
IN_DeactivateMouse ();
IN_ShowMouse ();
@ -987,7 +1009,7 @@ void AppActivate(BOOL fActive, BOOL minimize)
ShowWindow(mainwindow, SW_SHOWNORMAL);
}
}
else if ((modestate == MS_WINDOWED) && _windowed_mouse.value && key_dest == key_game)
else if ((modestate == MS_WINDOWED) && _windowed_mouse->value && key_dest == key_game)
{
IN_ActivateMouse ();
IN_HideMouse ();
@ -1005,7 +1027,7 @@ void AppActivate(BOOL fActive, BOOL minimize)
vid_wassuspended = true;
}
}
else if ((modestate == MS_WINDOWED) && _windowed_mouse.value)
else if ((modestate == MS_WINDOWED) && _windowed_mouse->value)
{
IN_DeactivateMouse ();
IN_ShowMouse ();
@ -1589,6 +1611,32 @@ void VID_Init (unsigned char *palette)
memset(&devmode, 0, sizeof(devmode));
<<<<<<< gl_vidnt.c
// Cvar_RegisterVariable (&vid_mode);
vid_mode = Cvar_Get ("vid_mode","0");
// Cvar_RegisterVariable (&vid_wait);
vid_wait = Cvar_Get ("vid_wait","0");
// Cvar_RegisterVariable (&vid_nopageflip);
_vid_nopageflip = Cvar_Get ("_vid_nopageflip","0",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&_vid_wait_override)
_vid_wait_override = Cvar_Get ("_vid_wait_override","0",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&_vid_default_mode);
_vid_default_mode = Cvar_Get ("_vid_default_mode","0",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&_vid_default_mode_win);
_vid_default_mode_win = Cvar_Get ("_vid_default_mode_win","0",
CVAR_ARCHIVE);
// Cvar_RegisterVariable (&vid_config_x);
vid_config_x = Cvar_Get ("vid_config_x","800",CVAR_ARCHIVE,"800");
// Cvar_RegisterVariable (&vid_config_y);
vid_config_y = Cvar_Get ("vid_config_y","600",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&vid_stretch_by_2);
vid_stretch_by_2 = Cvar_Get ("vid_stretch_by_2","1",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&_windowed_mouse);
_windowed_mouse = Cvar_Get ("_windowed_mouse","1",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&gl_ztrick);
gl_ztrick = Cvar_Get ("gl_ztrick","1",CVAR_ARCHIVE);
=======
Cvar_RegisterVariable (&vid_mode);
Cvar_RegisterVariable (&vid_wait);
Cvar_RegisterVariable (&vid_nopageflip);
@ -1599,6 +1647,7 @@ void VID_Init (unsigned char *palette)
Cvar_RegisterVariable (&vid_config_y);
Cvar_RegisterVariable (&vid_stretch_by_2);
Cvar_RegisterVariable (&gl_ztrick);
>>>>>>> 1.20
Cmd_AddCommand ("vid_nummodes", VID_NumModes_f);
Cmd_AddCommand ("vid_describecurrentmode", VID_DescribeCurrentMode_f);
@ -1959,14 +2008,14 @@ void VID_ExtraOptionDraw(unsigned int options_draw_cursor)
{
// Windowed Mouse
M_Print (16, options_draw_cursor+=8, " Use Mouse");
M_DrawCheckbox (220, options_draw_cursor, _windowed_mouse.value);
M_DrawCheckbox (220, options_draw_cursor, _windowed_mouse->value);
}
void VID_ExtraOptionCmd(int option_cursor)
{
switch(option_cursor) {
case 1: // _windowed_mouse
Cvar_SetValue ("_windowed_mouse", !_windowed_mouse.value);
Cvar_SetValue ("_windowed_mouse", !_windowed_mouse->value);
break;
}

8
common/gl_warp.c
View file

@ -43,7 +43,7 @@ float speedscale; // for top sky and bottom sky
msurface_t *warpface;
extern cvar_t gl_subdivide_size;
extern cvar_t *gl_subdivide_size;
/*
BoundPoly (int, float, vec3_t, vec3_t)
@ -87,7 +87,7 @@ SubdividePolygon ( int numverts, float *verts ) {
for (i=0 ; i<3 ; i++) {
m = (mins[i] + maxs[i]) * 0.5;
m = gl_subdivide_size.value * floor (m/gl_subdivide_size.value + 0.5);
m = gl_subdivide_size->value * floor (m/gl_subdivide_size->value + 0.5);
if (maxs[i] - m < 8)
continue;
if (m - mins[i] < 8)
@ -218,10 +218,10 @@ EmitWaterPolys ( msurface_t *fa ) {
glTexCoord2f (s, t);
if(r_waterripple.value) {
if(r_waterripple->value) {
nv[0] = v[0]; //+8*sin(v[1]*0.05+realtime)*sin(v[2]*0.05+realtime);
nv[1] = v[1]; //+8*sin(v[0]*0.05+realtime)*sin(v[2]*0.05+realtime);
nv[2] = v[2] + r_waterripple.value*sin(v[0]*0.05+realtime)*sin(v[2]*0.05+realtime);
nv[2] = v[2] + r_waterripple->value*sin(v[0]*0.05+realtime)*sin(v[2]*0.05+realtime);
glVertex3fv (nv);
} else {
glVertex3fv (v);

62
common/glquake.h
View file

@ -169,43 +169,43 @@ extern int playertextures;
extern int skytexturenum; // index in cl.loadmodel, not gl texture object
extern cvar_t r_norefresh;
extern cvar_t r_drawentities;
extern cvar_t r_drawworld;
extern cvar_t r_drawviewmodel;
extern cvar_t r_speeds;
extern cvar_t r_waterwarp;
extern cvar_t r_fullbright;
extern cvar_t r_lightmap;
extern cvar_t r_shadows;
extern cvar_t r_wateralpha;
extern cvar_t r_dynamic;
extern cvar_t r_novis;
extern cvar_t r_netgraph;
extern cvar_t r_fog;
extern cvar_t r_waterwarp;
extern cvar_t r_volfog;
extern cvar_t r_waterripple;
extern cvar_t *r_norefresh;
extern cvar_t *r_drawentities;
extern cvar_t *r_drawworld;
extern cvar_t *r_drawviewmodel;
extern cvar_t *r_speeds;
extern cvar_t *r_waterwarp;
extern cvar_t *r_fullbright;
extern cvar_t *r_lightmap;
extern cvar_t *r_shadows;
extern cvar_t *r_wateralpha;
extern cvar_t *r_dynamic;
extern cvar_t *r_novis;
extern cvar_t *r_netgraph;
extern cvar_t *r_fog;
extern cvar_t *r_waterwarp;
extern cvar_t *r_volfog;
extern cvar_t *r_waterripple;
extern cvar_t gl_clear;
extern cvar_t gl_cull;
extern cvar_t gl_poly;
extern cvar_t gl_texsort;
extern cvar_t gl_smoothmodels;
extern cvar_t gl_affinemodels;
extern cvar_t gl_polyblend;
extern cvar_t gl_keeptjunctions;
extern cvar_t gl_flashblend;
extern cvar_t gl_nocolors;
extern cvar_t gl_finish;
extern cvar_t gl_doubleeyes;
extern cvar_t *gl_clear;
extern cvar_t *gl_cull;
extern cvar_t *gl_poly;
extern cvar_t *gl_texsort;
extern cvar_t *gl_smoothmodels;
extern cvar_t *gl_affinemodels;
extern cvar_t *gl_polyblend;
extern cvar_t *gl_keeptjunctions;
extern cvar_t *gl_flashblend;
extern cvar_t *gl_nocolors;
extern cvar_t *gl_finish;
extern cvar_t *gl_doubleeyes;
extern int gl_lightmap_format;
extern int gl_solid_format;
extern int gl_alpha_format;
extern cvar_t gl_max_size;
extern cvar_t gl_playermip;
extern cvar_t *gl_max_size;
extern cvar_t *gl_playermip;
extern float r_world_matrix[16];

110
common/host.c
View file

@ -65,20 +65,34 @@ int fps_count;
int vcrFile = -1;
double host_time;
cvar_t sys_ticrate = {"sys_ticrate","0.05"};
cvar_t serverprofile = {"serverprofile", "0"};
cvar_t host_framerate = {"host_framerate", "0"}; // set for slow motion
cvar_t samelevel = {"samelevel", "0"};
cvar_t noexit = {"noexit", "0", CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t pausable = {"pausable", "1"};
cvar_t temp1 = {"temp1", "0"};
cvar_t sv_filter = {"sv_filter", "1"}; // strip \n, \r in names?
cvar_t teamplay = {"teamplay","0",CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t deathmatch = {"deathmatch","0"}; // 0, 1, or 2
cvar_t coop = {"coop","0"}; // 0 or 1
cvar_t fraglimit = {"fraglimit","0",CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t skill = {"skill","1"}; // 0 - 3
cvar_t timelimit = {"timelimit","0",CVAR_USERINFO|CVAR_SERVERINFO};
//cvar_t sys_ticrate = {"sys_ticrate","0.05"};
cvar_t *sys_ticrate;
//cvar_t serverprofile = {"serverprofile", "0"};
cvar_t *serverprofile;
//cvar_t host_framerate = {"host_framerate", "0"}; // set for slow motion
cvar_t *host_framerate;
//cvar_t samelevel = {"samelevel", "0"};
cvar_t *samelevel;
//cvar_t noexit = {"noexit", "0", CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *noexit;
//cvar_t pausable = {"pausable", "1"};
cvar_t *pausable;
//cvar_t temp1 = {"temp1", "0"};
cvar_t *temp1;
//cvar_t sv_filter = {"sv_filter", "1"}; // strip \n, \r in names?
cvar_t *sv_filter;
//cvar_t teamplay = {"teamplay","0",CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *teamplay;
//cvar_t deathmatch = {"deathmatch","0"}; // 0, 1, or 2
cvar_t *deathmatch;
//cvar_t coop = {"coop","0"}; // 0 or 1
cvar_t *coop;
//cvar_t fraglimit = {"fraglimit","0",CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *fraglimit;
//cvar_t skill = {"skill","1"}; // 0 - 3
cvar_t *skill;
//cvar_t timelimit = {"timelimit","0",CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *timelimit;
#ifdef UQUAKE
client_t *host_client; // current client
@ -195,11 +209,11 @@ Host_FilterTime ( float time )
if ( oldrealtime > realtime )
oldrealtime = 0;
if (cl_maxfps.value)
fps = max(30.0, min(cl_maxfps.value, MAXFPS));
if (cl_maxfps->value)
fps = max(30.0, min(cl_maxfps->value, MAXFPS));
else
#ifdef QUAKEWORLD
fps = max(30.0, min(rate.value/80.0, MAXFPS));
fps = max(30.0, min(rate->value/80.0, MAXFPS));
#elif UQUAKE
fps = MAXFPS;
#endif
@ -210,8 +224,8 @@ Host_FilterTime ( float time )
host_frametime = realtime - oldrealtime;
oldrealtime = realtime;
if (host_framerate.value > 0) {
host_frametime = host_framerate.value;
if (host_framerate->value > 0) {
host_frametime = host_framerate->value;
} else { // don't allow really long or short frames
host_frametime = min(MAXTIME, max(host_frametime, MINTIME));
}
@ -313,12 +327,12 @@ Host_FrameMain ( float time )
#endif
// update video
if (host_speeds.value)
if (host_speeds->value)
time1 = Sys_DoubleTime ();
SCR_UpdateScreen ();
if (host_speeds.value)
if (host_speeds->value)
time2 = Sys_DoubleTime ();
// update audio
@ -335,7 +349,7 @@ Host_FrameMain ( float time )
CDAudio_Update();
if (host_speeds.value) {
if (host_speeds->value) {
pass1 = (time1 - time3)*1000;
time3 = Sys_DoubleTime ();
pass2 = (time2 - time1)*1000;
@ -368,7 +382,7 @@ Host_Frame ( float time )
static int timecount;
int i, c, m;
if (!serverprofile.value) {
if (!serverprofile->value) {
Host_FrameMain (time);
return;
}
@ -658,6 +672,7 @@ Host_Shutdown( void )
#endif
VID_Shutdown();
}
Cvar_Shutdown ();
}
/*
@ -697,24 +712,41 @@ Host_InitLocal ( void )
{
Host_InitCommands ();
Cvar_RegisterVariable (&host_framerate);
// Cvar_RegisterVariable (&host_framerate);
host_framerate = Cvar_Get ("host_framerate","0",0,"None");
Cvar_RegisterVariable (&sys_ticrate);
Cvar_RegisterVariable (&serverprofile);
// Cvar_RegisterVariable (&sys_ticrate);
sys_ticrate = Cvar_Get ("sys_ticrate","0.05",0,"None");
// Cvar_RegisterVariable (&serverprofile);
serverprofile = Cvar_Get ("serverprofile","0",0,"None");
Cvar_RegisterVariable (&fraglimit);
Cvar_RegisterVariable (&timelimit);
Cvar_RegisterVariable (&teamplay);
Cvar_RegisterVariable (&samelevel);
Cvar_RegisterVariable (&noexit);
Cvar_RegisterVariable (&skill);
Cvar_RegisterVariable (&deathmatch);
Cvar_RegisterVariable (&coop);
// Cvar_RegisterVariable (&fraglimit);
fraglimit = Cvar_Get ("fraglimit","0",CVAR_USERINFO|CVAR_SERVERINFO,
"None");
// Cvar_RegisterVariable (&timelimit);
timelimit = Cvar_Get ("timelimit","0",CVAR_USERINFO|CVAR_SERVERINFO,
"None");
// Cvar_RegisterVariable (&teamplay);
teamplay = Cvar_Get ("teamplay","0",CVAR_USERINFO|CVAR_SERVERINFO,
"None");
// Cvar_RegisterVariable (&samelevel);
samelevel = Cvar_Get ("samelevel","0",0,"None");
// Cvar_RegisterVariable (&noexit);
noexit = Cvar_Get ("noexit","0",CVAR_USERINFO|CVAR_SERVERINFO,"None");
// Cvar_RegisterVariable (&skill);
skill = Cvar_Get ("skill","1",0,"None");
// Cvar_RegisterVariable (&deathmatch);
deathmatch = Cvar_Get ("deathmatch","0",0,"None");
// Cvar_RegisterVariable (&coop);
coop = Cvar_Get ("coop","0",0,"None");
Cvar_RegisterVariable (&pausable);
// Cvar_RegisterVariable (&pausable);
pausable = Cvar_Get ("pausable","1",0,"None");
Cvar_RegisterVariable (&temp1);
Cvar_RegisterVariable (&sv_filter);
// Cvar_RegisterVariable (&temp1);
temp1 = Cvar_Get ("temp1","0",0,"None");
// Cvar_RegisterVariable (&sv_filter);
sv_filter = Cvar_Get ("sv_filter","1",0,"None");
Host_FindMaxClients ();
@ -768,9 +800,9 @@ void Host_FindMaxClients (void)
svs.clients = Hunk_AllocName (svs.maxclientslimit*sizeof(client_t), "clients");
if (svs.maxclients > 1)
Cvar_SetValue ("deathmatch", 1.0);
deathmatch->value = 1.0;
else
Cvar_SetValue ("deathmatch", 0.0);
deathmatch->value = 0.0;
}
/*

70
common/in_dos.c
View file

@ -77,7 +77,8 @@ typedef struct
} externControl_t;
*/
cvar_t m_filter = {"m_filter","1"};
//cvar_t m_filter = {"m_filter","1"};
cvar_t *m_filter;
qboolean mouse_avail;
int mouse_buttons;
@ -87,8 +88,10 @@ float mouse_x, mouse_y;
float old_mouse_x, old_mouse_y;
cvar_t in_joystick = {"joystick","1"};
cvar_t joy_numbuttons = {"joybuttons","4", CVAR_ARCHIVE};
//cvar_t in_joystick = {"joystick","1"};
cvar_t *in_joystick;
//cvar_t joy_numbuttons = {"joybuttons","4", CVAR_ARCHIVE};
cvar_t *joy_numbuttons;
qboolean joy_avail;
int joy_oldbuttonstate;
@ -103,7 +106,8 @@ qboolean extern_avail;
int extern_buttons;
int extern_oldbuttonstate;
int extern_buttonstate;
cvar_t aux_look = {"auxlook","1", CVAR_ARCHIVE};
//cvar_t aux_look = {"auxlook","1", CVAR_ARCHIVE};
cvar_t *aux_look;
externControl_t *extern_control;
void IN_StartupExternal (void);
void IN_ExternalMove (usercmd_t *cmd);
@ -114,7 +118,7 @@ qboolean IN_ReadJoystick (void);
void Toggle_AuxLook_f (void)
{
if (aux_look.value)
if (aux_look->value)
Cvar_Set ("auxlook","0");
else
Cvar_Set ("auxlook","1");
@ -162,10 +166,14 @@ void IN_Init (void)
{
int i;
Cvar_RegisterVariable (&m_filter);
Cvar_RegisterVariable (&in_joystick);
Cvar_RegisterVariable (&joy_numbuttons);
Cvar_RegisterVariable (&aux_look);
// Cvar_RegisterVariable (&m_filter);
m_filter = Cvar_Get ("m_filter","1");
// Cvar_RegisterVariable (&in_joystick);
in_joystick = Cvar_Get ("in_joystick","1");
// Cvar_RegisterVariable (&joy_numbuttons);
joy_numbuttons = Cvar_Get ("joy_numbuttons","4",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&aux_look);
aux_look = Cvar_Get ("auxlook","1",CVAR_ARCHIVE);
Cmd_AddCommand ("toggle_auxlook", Toggle_AuxLook_f);
Cmd_AddCommand ("force_centerview", Force_CenterView_f);
@ -228,7 +236,7 @@ void IN_Frame(void)
{
joy_buttonstate = ((dos_inportb(0x201) >> 4)&15)^15;
// perform button actions
for (i=0 ; i<joy_numbuttons.value ; i++)
for (i=0 ; i<joy_numbuttons->value ; i++)
{
if ( (joy_buttonstate & (1<<i)) &&
!(joy_oldbuttonstate & (1<<i)) )
@ -287,7 +295,7 @@ void IN_MouseMove (usercmd_t *cmd)
mx = (short)regs.x.cx;
my = (short)regs.x.dx;
if (m_filter.value)
if (m_filter->value)
{
mouse_x = (mx + old_mouse_x) * 0.5;
mouse_y = (my + old_mouse_y) * 0.5;
@ -300,21 +308,21 @@ void IN_MouseMove (usercmd_t *cmd)
old_mouse_x = mx;
old_mouse_y = my;
mouse_x *= sensitivity.value;
mouse_y *= sensitivity.value;
mouse_x *= sensitivity->value;
mouse_y *= sensitivity->value;
// add mouse X/Y movement to cmd
if ( (in_strafe.state & 1) || (lookstrafe.value && (in_mlook.state & 1) ))
cmd->sidemove += m_side.value * mouse_x;
if ( (in_strafe.state & 1) || (lookstrafe->value && (in_mlook.state & 1) ))
cmd->sidemove += m_side->value * mouse_x;
else
cl.viewangles[YAW] -= m_yaw.value * mouse_x;
cl.viewangles[YAW] -= m_yaw->value * mouse_x;
if (in_mlook.state & 1)
V_StopPitchDrift ();
if ( (in_mlook.state & 1) && !(in_strafe.state & 1))
{
cl.viewangles[PITCH] += m_pitch.value * mouse_y;
cl.viewangles[PITCH] += m_pitch->value * mouse_y;
if (cl.viewangles[PITCH] > 80)
cl.viewangles[PITCH] = 80;
if (cl.viewangles[PITCH] < -70)
@ -323,9 +331,9 @@ void IN_MouseMove (usercmd_t *cmd)
else
{
if ((in_strafe.state & 1) && noclip_anglehack)
cmd->upmove -= m_forward.value * mouse_y;
cmd->upmove -= m_forward->value * mouse_y;
else
cmd->forwardmove -= m_forward.value * mouse_y;
cmd->forwardmove -= m_forward->value * mouse_y;
}
}
@ -338,7 +346,7 @@ void IN_JoyMove (usercmd_t *cmd)
{
float speed, aspeed;
if (!joy_avail || !in_joystick.value)
if (!joy_avail || !in_joystick->value)
return;
IN_ReadJoystick ();
@ -347,7 +355,7 @@ void IN_JoyMove (usercmd_t *cmd)
// reading time (win 95)
if (in_speed.state & 1)
speed = cl_movespeedkey.value;
speed = cl_movespeedkey->value;
else
speed = 1;
aspeed = speed*host_frametime;
@ -355,35 +363,35 @@ void IN_JoyMove (usercmd_t *cmd)
if (in_strafe.state & 1)
{
if (joystickx < joyxl)
cmd->sidemove -= speed*cl_sidespeed.value;
cmd->sidemove -= speed*cl_sidespeed->value;
else if (joystickx > joyxh)
cmd->sidemove += speed*cl_sidespeed.value;
cmd->sidemove += speed*cl_sidespeed->value;
}
else
{
if (joystickx < joyxl)
cl.viewangles[YAW] += aspeed*cl_yawspeed.value;
cl.viewangles[YAW] += aspeed*cl_yawspeed->value;
else if (joystickx > joyxh)
cl.viewangles[YAW] -= aspeed*cl_yawspeed.value;
cl.viewangles[YAW] -= aspeed*cl_yawspeed->value;
cl.viewangles[YAW] = anglemod(cl.viewangles[YAW]);
}
if (in_mlook.state & 1)
{
if (m_pitch.value < 0)
if (m_pitch->value < 0)
speed *= -1;
if (joysticky < joyyl)
cl.viewangles[PITCH] += aspeed*cl_pitchspeed.value;
cl.viewangles[PITCH] += aspeed*cl_pitchspeed->value;
else if (joysticky > joyyh)
cl.viewangles[PITCH] -= aspeed*cl_pitchspeed.value;
cl.viewangles[PITCH] -= aspeed*cl_pitchspeed->value;
}
else
{
if (joysticky < joyyl)
cmd->forwardmove += speed*cl_forwardspeed.value;
cmd->forwardmove += speed*cl_forwardspeed->value;
else if (joysticky > joyyh)
cmd->forwardmove -= speed*cl_backspeed.value;
cmd->forwardmove -= speed*cl_backspeed->value;
}
}
@ -609,7 +617,7 @@ Con_DPrintf("OUT: y:%f p:%f r:%f f:%f s:%f u:%f\n", extern_control->viewangles[Y
if (cl.viewangles[PITCH] < -70)
cl.viewangles[PITCH] = -70;
freelook = (extern_control->flags & AUX_FLAG_FREELOOK || aux_look.value || in_mlook.state & 1);
freelook = (extern_control->flags & AUX_FLAG_FREELOOK || aux_look->value || in_mlook.state & 1);
if (freelook)
V_StopPitchDrift ();

26
common/in_sun.c
View file

@ -62,7 +62,8 @@ extern int global_dx, global_dy;
// globals
//
cvar_t _windowed_mouse = {"_windowed_mouse","1", CVAR_ARCHIVE};
//cvar_t _windowed_mouse = {"_windowed_mouse","1", CVAR_ARCHIVE};
cvar_t *_windowed_mouse;
int x_root, y_root;
int x_root_old, y_root_old;
//
@ -97,7 +98,7 @@ void IN_CenterMouse( void )
//
static void CheckMouseState(void)
{
if (x_focus && _windowed_mouse.value && !x_grabbed) {
if (x_focus && _windowed_mouse->value && !x_grabbed) {
x_grabbed = true;
printf("fooling with mouse!\n");
if (XGetPointerControl( x_disp, &x_mouse_num, &x_mouse_denom, &x_mouse_thresh ))
@ -119,7 +120,7 @@ static void CheckMouseState(void)
// safe initial values
x_root = x_root_old = vid.width >> 1;
y_root = y_root_old = vid.height >> 1;
} else if (x_grabbed && (!_windowed_mouse.value || !x_focus)) {
} else if (x_grabbed && (!_windowed_mouse->value || !x_focus)) {
printf("fooling with mouse!\n");
x_grabbed = false;
// undo mouse warp
@ -141,7 +142,8 @@ void IN_Init (void)
{
if (!x_disp) Sys_Error( "X display not open!\n" );
Cvar_RegisterVariable (&_windowed_mouse);
// Cvar_RegisterVariable (&_windowed_mouse);
_windowed_mouse = Cvar_Get ("_windowed_mouse","1", CVAR_ARCHIVE);
// we really really want to clean these up...
atexit( IN_Shutdown );
@ -203,8 +205,8 @@ IN_Move(usercmd_t *cmd)
// printf("GOT: dx %d dy %d\n", dx, dy);
dx *= sensitivity.value;
dy *= sensitivity.value;
dx *= sensitivity->value;
dy *= sensitivity->value;
//
// implement low pass filter to smooth motion a bit
@ -229,21 +231,21 @@ IN_Move(usercmd_t *cmd)
}
// add mouse X/Y movement to cmd
if ((in_strafe.state & 1) || (lookstrafe.value && (in_mlook.state & 1)))
cmd->sidemove += m_side.value * dx;
if ((in_strafe.state & 1) || (lookstrafe->value && (in_mlook.state & 1)))
cmd->sidemove += m_side->value * dx;
else
cl.viewangles[YAW] -= m_yaw.value * dx;
cl.viewangles[YAW] -= m_yaw->value * dx;
if (in_mlook.state & 1)
V_StopPitchDrift ();
if ((in_mlook.state & 1) && !(in_strafe.state & 1)) {
cl.viewangles[PITCH] += m_pitch.value * dy;
cl.viewangles[PITCH] += m_pitch->value * dy;
if (cl.viewangles[PITCH] > 80) cl.viewangles[PITCH] = 80;
if (cl.viewangles[PITCH] < -70) cl.viewangles[PITCH] = -70;
}
else {
if ((in_strafe.state & 1) && noclip_anglehack) cmd->upmove -= m_forward.value * dy;
else cmd->forwardmove -= m_forward.value * dy;
if ((in_strafe.state & 1) && noclip_anglehack) cmd->upmove -= m_forward->value * dy;
else cmd->forwardmove -= m_forward->value * dy;
}
}

41
common/in_svgalib.c
View file

@ -56,16 +56,19 @@ static int mx, my;
static void IN_init_kb();
static void IN_init_mouse();
cvar_t _windowed_mouse = {"_windowed_mouse", "1", CVAR_ARCHIVE};
cvar_t m_filter = {"m_filter","0"};
//cvar_t _windowed_mouse = {"_windowed_mouse", "1", CVAR_ARCHIVE};
cvar_t *_windowed_mouse;
//cvar_t m_filter = {"m_filter","0"};
cvar_t *m_filter;
/*
static cvar_t mouse_button_commands[3] =
{
{"mouse1","+attack"},
{"mouse2","+strafe"},
{"mouse3","+forward"},
};
*/
static cvar_t *mouse_button_commands[3];
static void keyhandler(int scancode, int state)
{
@ -240,10 +243,14 @@ static void IN_init_mouse()
char *mousedev;
int mouserate = MOUSE_DEFAULTSAMPLERATE;
Cvar_RegisterVariable(&mouse_button_commands[0]);
Cvar_RegisterVariable(&mouse_button_commands[1]);
Cvar_RegisterVariable(&mouse_button_commands[2]);
Cvar_RegisterVariable(&m_filter);
// Cvar_RegisterVariable(&mouse_button_commands[0]);
mouse_button_commands[0] = Cvar_Get ("mouse1","+attack",0,"None");
// Cvar_RegisterVariable(&mouse_button_commands[1]);
mouse_button_commands[1] = Cvar_Get ("mouse2","+strafe",0,"None");
// Cvar_RegisterVariable(&mouse_button_commands[2]);
mouse_button_commands[2] = Cvar_Get ("mouse2","+forward",0,"None");
// Cvar_RegisterVariable(&m_filter);
m_filter = Cvar_Get ("m_filter","0",0,"None");
Cmd_AddCommand("force_centerview", Force_CenterView_f);
mouse_buttons = 3;
@ -338,7 +345,7 @@ void IN_Move(usercmd_t *cmd)
while (mouse_update())
;
if (m_filter.value) {
if (m_filter->value) {
mouse_x = (mx + old_mouse_x) * 0.5;
mouse_y = (my + old_mouse_y) * 0.5;
} else {
@ -350,21 +357,21 @@ void IN_Move(usercmd_t *cmd)
/* Clear for next update */
mx = my = 0;
mouse_x *= sensitivity.value;
mouse_y *= sensitivity.value;
mouse_x *= sensitivity->value;
mouse_y *= sensitivity->value;
/* Add mouse X/Y movement to cmd */
if ( (in_strafe.state & 1) ||
(lookstrafe.value && (in_mlook.state & 1) )) {
cmd->sidemove += m_side.value * mouse_x;
(lookstrafe->value && (in_mlook.state & 1) )) {
cmd->sidemove += m_side->value * mouse_x;
} else {
cl.viewangles[YAW] -= m_yaw.value * mouse_x;
cl.viewangles[YAW] -= m_yaw->value * mouse_x;
}
if ((in_mlook.state & 1)) V_StopPitchDrift();
if ((in_mlook.state & 1) && !(in_strafe.state & 1)) {
cl.viewangles[PITCH] += m_pitch.value * mouse_y;
cl.viewangles[PITCH] += m_pitch->value * mouse_y;
if (cl.viewangles[PITCH] > 80) {
cl.viewangles[PITCH] = 80;
}
@ -373,9 +380,9 @@ void IN_Move(usercmd_t *cmd)
}
} else {
if ((in_strafe.state & 1) && noclip_anglehack) {
cmd->upmove -= m_forward.value * mouse_y;
cmd->upmove -= m_forward->value * mouse_y;
} else {
cmd->forwardmove -= m_forward.value * mouse_y;
cmd->forwardmove -= m_forward->value * mouse_y;
}
}
}

200
common/in_win.c
View file

@ -43,7 +43,8 @@ HRESULT (WINAPI *pDirectInputCreate)(HINSTANCE hinst, DWORD dwVersion,
LPDIRECTINPUT * lplpDirectInput, LPUNKNOWN punkOuter);
// mouse variables
cvar_t m_filter = {"m_filter","0"};
//cvar_t m_filter = {"m_filter","0"};
cvar_t *m_filter;
int mouse_buttons;
int mouse_oldbuttonstate;
@ -92,25 +93,44 @@ PDWORD pdwRawValue[JOY_MAX_AXES];
// each time. this avoids any problems with getting back to a default usage
// or when changing from one controller to another. this way at least something
// works.
cvar_t in_joystick = {"joystick","0", CVAR_ARCHIVE};
cvar_t joy_name = {"joyname", "joystick"};
cvar_t joy_advanced = {"joyadvanced", "0"};
cvar_t joy_advaxisx = {"joyadvaxisx", "0"};
cvar_t joy_advaxisy = {"joyadvaxisy", "0"};
cvar_t joy_advaxisz = {"joyadvaxisz", "0"};
cvar_t joy_advaxisr = {"joyadvaxisr", "0"};
cvar_t joy_advaxisu = {"joyadvaxisu", "0"};
cvar_t joy_advaxisv = {"joyadvaxisv", "0"};
cvar_t joy_forwardthreshold = {"joyforwardthreshold", "0.15"};
cvar_t joy_sidethreshold = {"joysidethreshold", "0.15"};
cvar_t joy_pitchthreshold = {"joypitchthreshold", "0.15"};
cvar_t joy_yawthreshold = {"joyyawthreshold", "0.15"};
cvar_t joy_forwardsensitivity = {"joyforwardsensitivity", "-1.0"};
cvar_t joy_sidesensitivity = {"joysidesensitivity", "-1.0"};
cvar_t joy_pitchsensitivity = {"joypitchsensitivity", "1.0"};
cvar_t joy_yawsensitivity = {"joyyawsensitivity", "-1.0"};
cvar_t joy_wwhack1 = {"joywwhack1", "0.0"};
cvar_t joy_wwhack2 = {"joywwhack2", "0.0"};
//cvar_t in_joystick = {"joystick","0", CVAR_ARCHIVE};
cvar_t *in_joystick;
//cvar_t joy_name = {"joyname", "joystick"};
cvar_t *joy_name;
//cvar_t joy_advanced = {"joyadvanced", "0"};
cvar_t *joy_advanced;
//cvar_t joy_advaxisx = {"joyadvaxisx", "0"};
cvar_t *joy_advaxisx;
//cvar_t joy_advaxisy = {"joyadvaxisy", "0"};
cvar_t *joy_advaxisy;
//cvar_t joy_advaxisz = {"joyadvaxisz", "0"};
cvar_t *joy_advaxisz;
//cvar_t joy_advaxisr = {"joyadvaxisr", "0"};
cvar_t *joy_advaxisr;
//cvar_t joy_advaxisu = {"joyadvaxisu", "0"};
cvar_t *joy_advaxisu;
//cvar_t joy_advaxisv = {"joyadvaxisv", "0"};
cvar_t *joy_advaxisv;
//cvar_t joy_forwardthreshold = {"joyforwardthreshold", "0.15"};
cvar_t *joy_forwardthreshold;
//cvar_t joy_sidethreshold = {"joysidethreshold", "0.15"};
cvar_t *joy_sidethreshold;
//cvar_t joy_pitchthreshold = {"joypitchthreshold", "0.15"};
cvar_t *joy_pitchthreshold;
//cvar_t joy_yawthreshold = {"joyyawthreshold", "0.15"};
cvar_t *joy_yawthreshold;
//cvar_t joy_forwardsensitivity = {"joyforwardsensitivity", "-1.0"};
cvar_t *joy_forwardsensitivity;
//cvar_t joy_sidesensitivity = {"joysidesensitivity", "-1.0"};
cvar_t *joy_sidesensitivity;
//cvar_t joy_pitchsensitivity = {"joypitchsensitivity", "1.0"};
cvar_t *joy_pitchsensitivity;
//cvar_t joy_yawsensitivity = {"joyyawsensitivity", "-1.0"};
cvar_t *joy_yawsensitivity;
//cvar_t joy_wwhack1 = {"joywwhack1", "0.0"};
cvar_t *joy_wwhack1;
//cvar_t joy_wwhack2 = {"joywwhack2", "0.0"};
cvar_t *joy_wwhack2;
qboolean joy_avail, joy_advancedinit, joy_haspov;
DWORD joy_oldbuttonstate, joy_oldpovstate;
@ -492,28 +512,48 @@ IN_Init
void IN_Init (void)
{
// mouse variables
Cvar_RegisterVariable (&m_filter);
// Cvar_RegisterVariable (&m_filter);
m_filter = Cvar_Get ("m_filter","0");
// joystick variables
Cvar_RegisterVariable (&in_joystick);
Cvar_RegisterVariable (&joy_name);
Cvar_RegisterVariable (&joy_advanced);
Cvar_RegisterVariable (&joy_advaxisx);
Cvar_RegisterVariable (&joy_advaxisy);
Cvar_RegisterVariable (&joy_advaxisz);
Cvar_RegisterVariable (&joy_advaxisr);
Cvar_RegisterVariable (&joy_advaxisu);
Cvar_RegisterVariable (&joy_advaxisv);
Cvar_RegisterVariable (&joy_forwardthreshold);
Cvar_RegisterVariable (&joy_sidethreshold);
Cvar_RegisterVariable (&joy_pitchthreshold);
Cvar_RegisterVariable (&joy_yawthreshold);
Cvar_RegisterVariable (&joy_forwardsensitivity);
Cvar_RegisterVariable (&joy_sidesensitivity);
Cvar_RegisterVariable (&joy_pitchsensitivity);
Cvar_RegisterVariable (&joy_yawsensitivity);
Cvar_RegisterVariable (&joy_wwhack1);
Cvar_RegisterVariable (&joy_wwhack2);
// Cvar_RegisterVariable (&in_joystick);
in_joystick = Cvar_Get ("in_joystick","0",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&joy_name);
joy_name = Cvar_Get ("joy_name","joystick");
// Cvar_RegisterVariable (&joy_advanced);
joy_advanced = Cvar_Get ("joy_advanced","0");
// Cvar_RegisterVariable (&joy_advaxisx);
joy_advaxisx = Cvar_Get ("joy_advaxisx","0");
// Cvar_RegisterVariable (&joy_advaxisy);
joy_advaxisy = Cvar_Get ("joy_advaxisy","0");
// Cvar_RegisterVariable (&joy_advaxisz);
joy_advaxisz = Cvar_Get ("joy_advaxisz","0");
// Cvar_RegisterVariable (&joy_advaxisr);
joy_advaxisr = Cvar_Get ("joy_advaxisr","0");
// Cvar_RegisterVariable (&joy_advaxisu);
joy_advaxisu = Cvar_Get ("joy_advaxisu","0");
// Cvar_RegisterVariable (&joy_advaxisv);
joy_advaxisv = Cvar_Get ("joy_adaxisv","0");
// Cvar_RegisterVariable (&joy_forwardthreshold);
joy_forwardthreshold = Cvar_Get ("joy_forwardthreshold","0.15");
// Cvar_RegisterVariable (&joy_sidethreshold);
joy_sidethreshold = Cvar_Get ("joy_sidethreshold","0.15");
// Cvar_RegisterVariable (&joy_pitchthreshold);
joy_pitchthreshold = Cvar_Get ("joy_pitchthreshold","0.15");
// Cvar_RegisterVariable (&joy_yawthreshold);
joy_yawthreshold = Cvar_Get ("joy_yawthreshold","0.15");
// Cvar_RegisterVariable (&joy_forwardsensitivity);
joy_forwardsensitivity = Cvar_Get ("joy_forwardsensitivity","-1.0");
// Cvar_RegisterVariable (&joy_sidesensitivity);
joy_sidesensitivity = Cvar_Get ("joy_sidesensitivity","-1.0");
// Cvar_RegisterVariable (&joy_pitchsensitivity);
joy_pitchsensitivity = Cvar_Get ("joy_pitchsensitivity","-1.0");
// Cvar_RegisterVariable (&joy_yawsensitivity);
joy_yawsensitvity = Cvar_Get ("joy_yawsensitivity","-1.0");
// Cvar_RegisterVariable (&joy_wwhack1);
joy_wwhack1 = Cvar_Get ("joy_wwhack1","0.0");
// Cvar_RegisterVariable (&joy_wwhack2);
joy_wwhack2 = Cvar_Get ("joy_wwhack2","0.0");
Cmd_AddCommand ("force_centerview", Force_CenterView_f);
Cmd_AddCommand ("joyadvancedupdate", Joy_AdvancedUpdate_f);
@ -684,7 +724,7 @@ void IN_MouseMove (usercmd_t *cmd)
my_accum = 0;
}
if (m_filter.value)
if (m_filter->value)
{
mouse_x = (mx + old_mouse_x) * 0.5;
mouse_y = (my + old_mouse_y) * 0.5;
@ -698,21 +738,21 @@ void IN_MouseMove (usercmd_t *cmd)
old_mouse_x = mx;
old_mouse_y = my;
mouse_x *= sensitivity.value;
mouse_y *= sensitivity.value;
mouse_x *= sensitivity->value;
mouse_y *= sensitivity->value;
// add mouse X/Y movement to cmd
if ( (in_strafe.state & 1) || (lookstrafe.value && (in_mlook.state & 1) ))
cmd->sidemove += m_side.value * mouse_x;
if ( (in_strafe.state & 1) || (lookstrafe->value && (in_mlook.state & 1) ))
cmd->sidemove += m_side->value * mouse_x;
else
cl.viewangles[YAW] -= m_yaw.value * mouse_x;
cl.viewangles[YAW] -= m_yaw->value * mouse_x;
if (in_mlook.state & 1)
V_StopPitchDrift ();
if ( (in_mlook.state & 1) && !(in_strafe.state & 1))
{
cl.viewangles[PITCH] += m_pitch.value * mouse_y;
cl.viewangles[PITCH] += m_pitch->value * mouse_y;
if (cl.viewangles[PITCH] > 80)
cl.viewangles[PITCH] = 80;
if (cl.viewangles[PITCH] < -70)
@ -721,9 +761,9 @@ void IN_MouseMove (usercmd_t *cmd)
else
{
if ((in_strafe.state & 1) && noclip_anglehack)
cmd->upmove -= m_forward.value * mouse_y;
cmd->upmove -= m_forward->value * mouse_y;
else
cmd->forwardmove -= m_forward.value * mouse_y;
cmd->forwardmove -= m_forward->value * mouse_y;
}
// if the mouse has moved, force it to the center, so there's room to move
@ -904,7 +944,7 @@ void Joy_AdvancedUpdate_f (void)
pdwRawValue[i] = RawValuePointer(i);
}
if( joy_advanced.value == 0.0)
if( joy_advanced->value == 0.0)
{
// default joystick initialization
// 2 axes only with joystick control
@ -923,22 +963,22 @@ void Joy_AdvancedUpdate_f (void)
// advanced initialization here
// data supplied by user via joy_axisn cvars
dwTemp = (DWORD) joy_advaxisx.value;
dwTemp = (DWORD) joy_advaxisx->value;
dwAxisMap[JOY_AXIS_X] = dwTemp & 0x0000000f;
dwControlMap[JOY_AXIS_X] = dwTemp & JOY_RELATIVE_AXIS;
dwTemp = (DWORD) joy_advaxisy.value;
dwTemp = (DWORD) joy_advaxisy->value;
dwAxisMap[JOY_AXIS_Y] = dwTemp & 0x0000000f;
dwControlMap[JOY_AXIS_Y] = dwTemp & JOY_RELATIVE_AXIS;
dwTemp = (DWORD) joy_advaxisz.value;
dwTemp = (DWORD) joy_advaxisz->value;
dwAxisMap[JOY_AXIS_Z] = dwTemp & 0x0000000f;
dwControlMap[JOY_AXIS_Z] = dwTemp & JOY_RELATIVE_AXIS;
dwTemp = (DWORD) joy_advaxisr.value;
dwTemp = (DWORD) joy_advaxisr->value;
dwAxisMap[JOY_AXIS_R] = dwTemp & 0x0000000f;
dwControlMap[JOY_AXIS_R] = dwTemp & JOY_RELATIVE_AXIS;
dwTemp = (DWORD) joy_advaxisu.value;
dwTemp = (DWORD) joy_advaxisu->value;
dwAxisMap[JOY_AXIS_U] = dwTemp & 0x0000000f;
dwControlMap[JOY_AXIS_U] = dwTemp & JOY_RELATIVE_AXIS;
dwTemp = (DWORD) joy_advaxisv.value;
dwTemp = (DWORD) joy_advaxisv->value;
dwAxisMap[JOY_AXIS_V] = dwTemp & 0x0000000f;
dwControlMap[JOY_AXIS_V] = dwTemp & JOY_RELATIVE_AXIS;
}
@ -1044,7 +1084,7 @@ qboolean IN_ReadJoystick (void)
// this is a hack -- there is a bug in the Logitech WingMan Warrior DirectInput Driver
// rather than having 32768 be the zero point, they have the zero point at 32668
// go figure -- anyway, now we get the full resolution out of the device
if (joy_wwhack1.value != 0.0)
if (joy_wwhack1->value != 0.0)
{
ji.dwUpos += 100;
}
@ -1082,7 +1122,7 @@ void IN_JoyMove (usercmd_t *cmd)
}
// verify joystick is available and that the user wants to use it
if (!joy_avail || !in_joystick.value)
if (!joy_avail || !in_joystick->value)
{
return;
}
@ -1094,7 +1134,7 @@ void IN_JoyMove (usercmd_t *cmd)
}
if (in_speed.state & 1)
speed = cl_movespeedkey.value;
speed = cl_movespeedkey->value;
else
speed = 1;
aspeed = speed * host_frametime;
@ -1107,7 +1147,7 @@ void IN_JoyMove (usercmd_t *cmd)
// move centerpoint to zero
fAxisValue -= 32768.0;
if (joy_wwhack2.value != 0.0)
if (joy_wwhack2->value != 0.0)
{
if (dwAxisMap[i] == AxisTurn)
{
@ -1129,20 +1169,20 @@ void IN_JoyMove (usercmd_t *cmd)
switch (dwAxisMap[i])
{
case AxisForward:
if ((joy_advanced.value == 0.0) && (in_mlook.state & 1))
if ((joy_advanced->value == 0.0) && (in_mlook.state & 1))
{
// user wants forward control to become look control
if (fabs(fAxisValue) > joy_pitchthreshold.value)
if (fabs(fAxisValue) > joy_pitchthreshold->value)
{
// if mouse invert is on, invert the joystick pitch value
// only absolute control support here (joy_advanced is false)
if (m_pitch.value < 0.0)
if (m_pitch->value < 0.0)
{
cl.viewangles[PITCH] -= (fAxisValue * joy_pitchsensitivity.value) * aspeed * cl_pitchspeed.value;
cl.viewangles[PITCH] -= (fAxisValue * joy_pitchsensitivity->value) * aspeed * cl_pitchspeed->value;
}
else
{
cl.viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity.value) * aspeed * cl_pitchspeed.value;
cl.viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity->value) * aspeed * cl_pitchspeed->value;
}
V_StopPitchDrift();
}
@ -1152,48 +1192,48 @@ void IN_JoyMove (usercmd_t *cmd)
// disable pitch return-to-center unless requested by user
// *** this code can be removed when the lookspring bug is fixed
// *** the bug always has the lookspring feature on
if(lookspring.value == 0.0)
if(lookspring->value == 0.0)
V_StopPitchDrift();
}
}
else
{
// user wants forward control to be forward control
if (fabs(fAxisValue) > joy_forwardthreshold.value)
if (fabs(fAxisValue) > joy_forwardthreshold->value)
{
cmd->forwardmove += (fAxisValue * joy_forwardsensitivity.value) * speed * cl_forwardspeed.value;
cmd->forwardmove += (fAxisValue * joy_forwardsensitivity->value) * speed * cl_forwardspeed->value;
}
}
break;
case AxisSide:
if (fabs(fAxisValue) > joy_sidethreshold.value)
if (fabs(fAxisValue) > joy_sidethreshold->value)
{
cmd->sidemove += (fAxisValue * joy_sidesensitivity.value) * speed * cl_sidespeed.value;
cmd->sidemove += (fAxisValue * joy_sidesensitivity->value) * speed * cl_sidespeed->value;
}
break;
case AxisTurn:
if ((in_strafe.state & 1) || (lookstrafe.value && (in_mlook.state & 1)))
if ((in_strafe.state & 1) || (lookstrafe->value && (in_mlook.state & 1)))
{
// user wants turn control to become side control
if (fabs(fAxisValue) > joy_sidethreshold.value)
if (fabs(fAxisValue) > joy_sidethreshold->value)
{
cmd->sidemove -= (fAxisValue * joy_sidesensitivity.value) * speed * cl_sidespeed.value;
cmd->sidemove -= (fAxisValue * joy_sidesensitivity->value) * speed * cl_sidespeed->value;
}
}
else
{
// user wants turn control to be turn control
if (fabs(fAxisValue) > joy_yawthreshold.value)
if (fabs(fAxisValue) > joy_yawthreshold->value)
{
if(dwControlMap[i] == JOY_ABSOLUTE_AXIS)
{
cl.viewangles[YAW] += (fAxisValue * joy_yawsensitivity.value) * aspeed * cl_yawspeed.value;
cl.viewangles[YAW] += (fAxisValue * joy_yawsensitivity->value) * aspeed * cl_yawspeed->value;
}
else
{
cl.viewangles[YAW] += (fAxisValue * joy_yawsensitivity.value) * speed * 180.0;
cl.viewangles[YAW] += (fAxisValue * joy_yawsensitivity->value) * speed * 180.0;
}
}
@ -1203,16 +1243,16 @@ void IN_JoyMove (usercmd_t *cmd)
case AxisLook:
if (in_mlook.state & 1)
{
if (fabs(fAxisValue) > joy_pitchthreshold.value)
if (fabs(fAxisValue) > joy_pitchthreshold->value)
{
// pitch movement detected and pitch movement desired by user
if(dwControlMap[i] == JOY_ABSOLUTE_AXIS)
{
cl.viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity.value) * aspeed * cl_pitchspeed.value;
cl.viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity->value) * aspeed * cl_pitchspeed->value;
}
else
{
cl.viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity.value) * speed * 180.0;
cl.viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity->value) * speed * 180.0;
}
V_StopPitchDrift();
}
@ -1222,7 +1262,7 @@ void IN_JoyMove (usercmd_t *cmd)
// disable pitch return-to-center unless requested by user
// *** this code can be removed when the lookspring bug is fixed
// *** the bug always has the lookspring feature on
if(lookspring.value == 0.0)
if(lookspring->value == 0.0)
V_StopPitchDrift();
}
}

53
common/in_x11.c
View file

@ -61,11 +61,14 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include <strings.h>
#endif
cvar_t _windowed_mouse = {"_windowed_mouse","0", CVAR_ARCHIVE};
cvar_t m_filter = {"m_filter","0", CVAR_ARCHIVE};
//cvar_t _windowed_mouse = {"_windowed_mouse","0", CVAR_ARCHIVE};
cvar_t *_windowed_mouse;
//cvar_t m_filter = {"m_filter","0", CVAR_ARCHIVE};
cvar_t *m_filter;
#ifdef HAS_DGA
qboolean dgamouse = 0;
static cvar_t vid_dga_mouseaccel = {"vid_dga_mouseaccel", "1", CVAR_ARCHIVE};
//static cvar_t vid_dga_mouseaccel = {"vid_dga_mouseaccel", "1", CVAR_ARCHIVE};
static cvar_t *vid_dga_mouseaccel;
#endif
static qboolean mouse_avail;
@ -240,11 +243,11 @@ static void event_motion(XEvent *event)
{
#ifdef HAS_DGA
if (dgamouse) {
mouse_x += event->xmotion.x_root * vid_dga_mouseaccel.value;
mouse_y += event->xmotion.y_root * vid_dga_mouseaccel.value;
mouse_x += event->xmotion.x_root * vid_dga_mouseaccel->value;
mouse_y += event->xmotion.y_root * vid_dga_mouseaccel->value;
} else
#endif
if (_windowed_mouse.value) {
if (_windowed_mouse->value) {
mouse_x = (float) ((int) event->xmotion.x - ((int) vid.width / 2));
mouse_y = (float) ((int) event->xmotion.y - ((int) vid.height / 2));
@ -265,10 +268,10 @@ static void event_motion(XEvent *event)
void
IN_Frame(void)
{
if (old_windowed_mouse != _windowed_mouse.value) {
old_windowed_mouse = _windowed_mouse.value;
if (old_windowed_mouse != _windowed_mouse->value) {
old_windowed_mouse = _windowed_mouse->value;
if (!_windowed_mouse.value) {
if (!_windowed_mouse->value) {
/* ungrab the pointer */
XUngrabPointer(x_disp,CurrentTime);
} else {
@ -293,7 +296,7 @@ void IN_Move(usercmd_t *cmd)
if (!mouse_avail)
return;
if (m_filter.value) {
if (m_filter->value) {
mouse_x = (mouse_x + old_mouse_x) * 0.5;
mouse_y = (mouse_y + old_mouse_y) * 0.5;
}
@ -301,27 +304,27 @@ void IN_Move(usercmd_t *cmd)
old_mouse_x = mouse_x;
old_mouse_y = mouse_y;
mouse_x *= sensitivity.value;
mouse_y *= sensitivity.value;
mouse_x *= sensitivity->value;
mouse_y *= sensitivity->value;
if ( (in_strafe.state & 1) || (lookstrafe.value && (in_mlook.state & 1) ))
cmd->sidemove += m_side.value * mouse_x;
if ( (in_strafe.state & 1) || (lookstrafe->value && (in_mlook.state & 1) ))
cmd->sidemove += m_side->value * mouse_x;
else
cl.viewangles[YAW] -= m_yaw.value * mouse_x;
cl.viewangles[YAW] -= m_yaw->value * mouse_x;
if (in_mlook.state & 1)
V_StopPitchDrift ();
if ( (in_mlook.state & 1) && !(in_strafe.state & 1)) {
cl.viewangles[PITCH] += m_pitch.value * mouse_y;
cl.viewangles[PITCH] += m_pitch->value * mouse_y;
if (cl.viewangles[PITCH] > 80)
cl.viewangles[PITCH] = 80;
if (cl.viewangles[PITCH] < -70)
cl.viewangles[PITCH] = -70;
} else {
if ((in_strafe.state & 1) && noclip_anglehack)
cmd->upmove -= m_forward.value * mouse_y;
cmd->upmove -= m_forward->value * mouse_y;
else
cmd->forwardmove -= m_forward.value * mouse_y;
cmd->forwardmove -= m_forward->value * mouse_y;
}
mouse_x = mouse_y = 0.0;
}
@ -331,14 +334,14 @@ static void IN_ExtraOptionDraw(unsigned int options_draw_cursor)
{
// Windowed Mouse
M_Print(16, options_draw_cursor+=8, " Use Mouse");
M_DrawCheckbox(220, options_draw_cursor, _windowed_mouse.value);
M_DrawCheckbox(220, options_draw_cursor, _windowed_mouse->value);
}
static void IN_ExtraOptionCmd(int option_cursor)
{
switch (option_cursor) {
case 1: // _windowed_mouse
Cvar_SetValue ("_windowed_mouse", !_windowed_mouse.value);
Cvar_SetValue ("_windowed_mouse", !_windowed_mouse->value);
break;
}
}
@ -364,10 +367,14 @@ int IN_Init ()
XChangeWindowAttributes(x_disp, x_win, attribmask, &attribs_2);
}
Cvar_RegisterVariable(&_windowed_mouse);
Cvar_RegisterVariable(&m_filter);
// Cvar_RegisterVariable(&_windowed_mouse);
_windowed_mouse = Cvar_Get ("_windowed_mouse","0",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable(&m_filter);
m_filter = Cvar_Get ("m_filter","0",CVAR_ARCHIVE,"None");
#ifdef HAS_DGA
Cvar_RegisterVariable(&vid_dga_mouseaccel);
// Cvar_RegisterVariable(&vid_dga_mouseaccel);
vid_dga_mouseaccel = Cvar_Get ("vid_dga_mouseaccel","1",CVAR_ARCHIVE,
"None");
#endif
if (COM_CheckParm("-nomouse")) return 1;
mouse_x = mouse_y = 0.0;

2
common/net.h
View file

@ -270,7 +270,7 @@ qboolean Netchan_CanPacket (netchan_t *chan);
qboolean Netchan_CanReliable (netchan_t *chan);
#endif
extern cvar_t hostname;
extern cvar_t *hostname;
#ifdef UQUAKE
qsocket_t *NET_NewQSocket (void);

11
common/plugin.c
View file

@ -46,10 +46,17 @@
#include <plugin.h>
#include <cvar.h>
cvar_t drv_path = {"drv_path", ".:" LIBDIR "/quakeforge"};
//cvar_t drv_path = {"drv_path", ".:" LIBDIR "/quakeforge"};
cvar_t *fs_drvpath;
input_pi *IN;
void Plugin_Init ()
{
fs_drvpath = Cvar_Get ("fs_drvpath",".:" LIBDIR "/quakeforge",0,"None");
}
#ifndef WIN32
void *_plugin_load(const char *filename)
@ -59,7 +66,7 @@ void *_plugin_load(const char *filename)
char *path,*end;
int len;
for (path = drv_path.string; *path; path=end) {
for (path = fs_drvpath->string; *path; path=end) {
end = strchr(path,':');
if (!end)
end = strchr(path,0);

16
common/pr_cmds.c
View file

@ -1375,11 +1375,11 @@ Pick a vector for the player to shoot along
vector aim(entity, missilespeed)
=============
*/
#ifdef QUAKEWORLD
cvar_t sv_aim = {"sv_aim", "2"};
#else
cvar_t sv_aim = {"sv_aim", "0.93"};
#endif
//#ifdef QUAKEWORLD cvar_t sv_aim = {"sv_aim", "2"};
cvar_t *sv_aim;
//#else cvar_t sv_aim = {"sv_aim", "0.93"};
void PF_aim (void)
{
edict_t *ent, *check, *bestent;
@ -1416,7 +1416,7 @@ void PF_aim (void)
VectorMA (start, 2048, dir, end);
tr = SV_Move (start, vec3_origin, vec3_origin, end, false, ent);
if (tr.ent && tr.ent->v.takedamage == DAMAGE_AIM
&& (!teamplay.value || ent->v.team <=0 || ent->v.team != tr.ent->v.team) )
&& (!teamplay->value || ent->v.team <=0 || ent->v.team != tr.ent->v.team) )
{
VectorCopy (pr_global_struct->v_forward, G_VECTOR(OFS_RETURN));
return;
@ -1425,7 +1425,7 @@ void PF_aim (void)
// try all possible entities
VectorCopy (dir, bestdir);
bestdist = sv_aim.value;
bestdist = sv_aim->value;
bestent = NULL;
check = NEXT_EDICT(sv.edicts);
@ -1435,7 +1435,7 @@ void PF_aim (void)
continue;
if (check == ent)
continue;
if (teamplay.value && ent->v.team > 0 && ent->v.team == check->v.team)
if (teamplay->value && ent->v.team > 0 && ent->v.team == check->v.team)
continue; // don't aim at teammate
for (j=0 ; j<3 ; j++)
end[j] = check->v.origin[j]

68
common/pr_edict.c
View file

@ -57,17 +57,28 @@ ddef_t *ED_FieldAtOfs (int ofs);
qboolean ED_ParseEpair (void *base, ddef_t *key, char *s);
#ifndef QUAKEWORLD
cvar_t nomonsters = {"nomonsters", "0"};
cvar_t gamecfg = {"gamecfg", "0"};
cvar_t scratch1 = {"scratch1", "0"};
cvar_t scratch2 = {"scratch2", "0"};
cvar_t scratch3 = {"scratch3", "0"};
cvar_t scratch4 = {"scratch4", "0"};
cvar_t savedgamecfg = {"savedgamecfg", "0", CVAR_ARCHIVE};
cvar_t saved1 = {"saved1", "0", CVAR_ARCHIVE};
cvar_t saved2 = {"saved2", "0", CVAR_ARCHIVE};
cvar_t saved3 = {"saved3", "0", CVAR_ARCHIVE};
cvar_t saved4 = {"saved4", "0", CVAR_ARCHIVE};
//cvar_t nomonsters = {"nomonsters", "0"};
cvar_t *nomonsters;
//cvar_t gamecfg = {"gamecfg", "0"};
cvar_t *gamecfg;
//cvar_t scratch1 = {"scratch1", "0"};
cvar_t *scratch1;
//cvar_t scratch2 = {"scratch2", "0"};
cvar_t *scratch2;
//cvar_t scratch3 = {"scratch3", "0"};
cvar_t *scratch3;
//cvar_t scratch4 = {"scratch4", "0"};
cvar_t *scratch4;
//cvar_t savedgamecfg = {"savedgamecfg", "0", CVAR_ARCHIVE};
cvar_t *savedgamecfg;
//cvar_t saved1 = {"saved1", "0", CVAR_ARCHIVE};
cvar_t *saved1;
//cvar_t saved2 = {"saved2", "0", CVAR_ARCHIVE};
cvar_t *saved2;
//cvar_t saved3 = {"saved3", "0", CVAR_ARCHIVE};
cvar_t *saved3;
//cvar_t saved4 = {"saved4", "0", CVAR_ARCHIVE};
cvar_t *saved4;
#endif
#define MAX_FIELD_LEN 64
@ -1017,7 +1028,7 @@ void ED_LoadFromFile (char *data)
// remove things from different skill levels or deathmatch
#ifndef QUAKEWORLD
if (deathmatch.value)
if (deathmatch->value)
{
#endif
if (((int)ent->v.spawnflags & SPAWNFLAG_NOT_DEATHMATCH))
@ -1220,17 +1231,28 @@ void PR_Init (void)
Cmd_AddCommand ("edictcount", ED_Count);
Cmd_AddCommand ("profile", PR_Profile_f);
#ifndef QUAKEWORLD
Cvar_RegisterVariable (&nomonsters);
Cvar_RegisterVariable (&gamecfg);
Cvar_RegisterVariable (&scratch1);
Cvar_RegisterVariable (&scratch2);
Cvar_RegisterVariable (&scratch3);
Cvar_RegisterVariable (&scratch4);
Cvar_RegisterVariable (&savedgamecfg);
Cvar_RegisterVariable (&saved1);
Cvar_RegisterVariable (&saved2);
Cvar_RegisterVariable (&saved3);
Cvar_RegisterVariable (&saved4);
// Cvar_RegisterVariable (&nomonsters);
nomonsters = Cvar_Get ("nomonsters","0",0,"None");
// Cvar_RegisterVariable (&gamecfg);
gamecfg = Cvar_Get ("gamecfg","0",0,"None");
// Cvar_RegisterVariable (&scratch1);
scratch1 = Cvar_Get ("scratch1","0",0,"None");
// Cvar_RegisterVariable (&scratch2);
scratch2 = Cvar_Get ("scratch2","0",0,"None");
// Cvar_RegisterVariable (&scratch3);
scratch3 = Cvar_Get ("scratch3","0",0,"None");
// Cvar_RegisterVariable (&scratch4);
scratch4 = Cvar_Get ("scratch4","0",0,"None");
// Cvar_RegisterVariable (&savedgamecfg);
savedgamecfg = Cvar_Get ("savedgamecfg","0",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&saved1);
saved1 = Cvar_Get ("saved1","0",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&saved2);
saved2 = Cvar_Get ("saved2","0",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&saved3);
saved3 = Cvar_Get ("saved3","0",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&saved4);
saved4 = Cvar_Get ("saved4","0",CVAR_ARCHIVE,"None");
#endif
}

7
common/qargs.c
View file

@ -36,6 +36,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include <cmd.h>
#include <console.h>
#include <client.h>
#include <assert.h>
#include "lib_replace.h"
usercmd_t nullcmd; // guarenteed to be zero
@ -51,7 +52,8 @@ static char *safeargvs[] =
int com_argc;
char **com_argv;
char *com_cmdline;
cvar_t cmdline = {"cmdline","0", false, true};
//cvar_t cmdline = {"cmdline","0", false, true};
cvar_t *cmdline;
/*
================
@ -95,7 +97,7 @@ void COM_InitArgv (int argc, char **argv)
largv[com_argc] = argv[com_argc];
if ((argv[com_argc]) && !Q_strcmp ("-safe", argv[com_argc]))
safe = true;
len += strlen (argv[com_argc]) + 1;
len += strlen (argv[com_argc]) + 2;
}
com_cmdline = (char*)malloc (len); // len is strlen(com_cmdline)+1 already
@ -103,6 +105,7 @@ void COM_InitArgv (int argc, char **argv)
for (i=0; i < argc; i++)
{
strncat (com_cmdline, argv[i], len);
assert(len - strlen(com_cmdline) > 0);
strncat (com_cmdline, " ", len);
}
com_cmdline[len] = 0;

4
common/quakedef.h
View file

@ -29,7 +29,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include <bothdefs.h>
#include <pmove.h>
extern cvar_t password;
extern cvar_t *password;
qboolean Host_SimulationTime(float time);
void Host_ClearMemory (void);
@ -44,7 +44,7 @@ extern int minimum_memory;
/*
Chase camera
*/
extern cvar_t cl_chasecam;
extern cvar_t *cl_chasecam;
void Chase_Init (void);
void Chase_Reset (void);

4
common/quakefs.c
View file

@ -346,7 +346,7 @@ int COM_FOpenFile (char *filename, QFile **gzfile)
#endif
if (fn)
{ // found it!
if(developer.value)
if(developer->value)
Sys_Printf ("PackFile: %s : %s\n",pak->filename, fn);
// open a new file on the pakfile
//*file = fopen (pak->filename, "rb");
@ -378,7 +378,7 @@ int COM_FOpenFile (char *filename, QFile **gzfile)
continue;
}
if(developer.value)
if(developer->value)
Sys_Printf ("FindFile: %s\n",netpath);
//*file = fopen (netpath, "rb");

2
common/r_edge.c
View file

@ -145,7 +145,7 @@ void R_BeginEdgeFrame (void)
surfaces[1].flags = SURF_DRAWBACKGROUND;
// put the background behind everything in the world
if (r_draworder.value)
if (r_draworder->value)
{
pdrawfunc = R_GenerateSpansBackward;
surfaces[1].key = 0;

222
common/r_main.c
View file

@ -135,35 +135,59 @@ void R_InitParticles (void);
void R_DrawParticles (void);
#endif // UQUAKE
cvar_t r_draworder = {"r_draworder","0"};
cvar_t r_speeds = {"r_speeds","0"};
cvar_t r_timegraph = {"r_timegraph","0"};
#ifdef QUAKEWORLD
cvar_t r_netgraph = {"r_netgraph","0"};
cvar_t r_zgraph = {"r_zgraph","0"};
cvar_t r_graphheight = {"r_graphheight","15"};
#else
cvar_t r_graphheight = {"r_graphheight","10"};
#endif // QUAKEWORLD
cvar_t r_clearcolor = {"r_clearcolor","2"};
cvar_t r_waterwarp = {"r_waterwarp","1"};
cvar_t r_fullbright = {"r_fullbright","0"};
cvar_t r_drawentities = {"r_drawentities","1"};
cvar_t r_drawviewmodel = {"r_drawviewmodel","1"};
cvar_t r_aliasstats = {"r_polymodelstats","0"};
cvar_t r_dspeeds = {"r_dspeeds","0"};
cvar_t r_drawflat = {"r_drawflat", "0"};
cvar_t r_ambient = {"r_ambient", "0"};
cvar_t r_reportsurfout = {"r_reportsurfout", "0"};
cvar_t r_maxsurfs = {"r_maxsurfs", "0"};
cvar_t r_numsurfs = {"r_numsurfs", "0"};
cvar_t r_reportedgeout = {"r_reportedgeout", "0"};
cvar_t r_maxedges = {"r_maxedges", "0"};
cvar_t r_numedges = {"r_numedges", "0"};
cvar_t r_aliastransbase = {"r_aliastransbase", "200"};
cvar_t r_aliastransadj = {"r_aliastransadj", "100"};
//cvar_t r_draworder = {"r_draworder","0"};
cvar_t *r_draworder;
//cvar_t r_speeds = {"r_speeds","0"};
cvar_t *r_speeds;
//cvar_t r_timegraph = {"r_timegraph","0"};
cvar_t *r_timegraph;
//#ifdef QUAKEWORLD
//cvar_t r_netgraph = {"r_netgraph","0"};
cvar_t *r_netgraph;
//cvar_t r_zgraph = {"r_zgraph","0"};
cvar_t *r_zgraph;
//cvar_t r_graphheight = {"r_graphheight","15"};
cvar_t *r_graphheight;
//#else
//cvar_t r_graphheight = {"r_graphheight","10"};
extern cvar_t scr_fov;
//#endif // QUAKEWORLD
//cvar_t r_clearcolor = {"r_clearcolor","2"};
cvar_t *r_clearcolor;
//cvar_t r_waterwarp = {"r_waterwarp","1"};
cvar_t *r_waterwarp;
//cvar_t r_fullbright = {"r_fullbright","0"};
cvar_t *r_fullbright;
//cvar_t r_drawentities = {"r_drawentities","1"};
cvar_t *r_drawentities;
//cvar_t r_drawviewmodel = {"r_drawviewmodel","1"};
cvar_t *r_drawviewmodel;
//cvar_t r_aliasstats = {"r_polymodelstats","0"};
cvar_t *r_aliasstats;
//cvar_t r_dspeeds = {"r_dspeeds","0"};
cvar_t *r_dspeeds;
//cvar_t r_drawflat = {"r_drawflat", "0"};
cvar_t *r_drawflat;
//cvar_t r_ambient = {"r_ambient", "0"};
cvar_t *r_ambient;
//cvar_t r_reportsurfout = {"r_reportsurfout", "0"};
cvar_t *r_reportsurfout;
//cvar_t r_maxsurfs = {"r_maxsurfs", "0"};
cvar_t *r_maxsurfs;
//cvar_t r_numsurfs = {"r_numsurfs", "0"};
cvar_t *r_numsurfs;
//cvar_t r_reportedgeout = {"r_reportedgeout", "0"};
cvar_t *r_reportedgeout;
// cvar_t r_maxedges = {"r_maxedges", "0"};
cvar_t *r_maxedges;
//cvar_t r_numedges = {"r_numedges", "0"};
cvar_t *r_numedges;
//cvar_t r_aliastransbase = {"r_aliastransbase", "200"};
cvar_t *r_aliastransbase;
//cvar_t r_aliastransadj = {"r_aliastransadj", "100"};
cvar_t *r_aliastransadj;
extern cvar_t *scr_fov;
void CreatePassages (void);
void SetVisibilityByPassages (void);
@ -223,34 +247,58 @@ void R_Init (void)
Cmd_AddCommand ("timerefresh", R_TimeRefresh_f);
Cmd_AddCommand ("pointfile", R_ReadPointFile_f);
Cvar_RegisterVariable (&r_draworder);
Cvar_RegisterVariable (&r_speeds);
Cvar_RegisterVariable (&r_timegraph);
// Cvar_RegisterVariable (&r_draworder);
r_draworder = Cvar_Get ("r_draworder","0",0,"None");
// Cvar_RegisterVariable (&r_speeds);
r_speeds = Cvar_Get ("r_speeds","0",0,"None");
// Cvar_RegisterVariable (&r_timegraph);
r_timegraph = Cvar_Get ("r_timegraph","0",0,"None");
#ifdef QUAKEWORLD
Cvar_RegisterVariable (&r_netgraph);
Cvar_RegisterVariable (&r_zgraph);
// Cvar_RegisterVariable (&r_netgraph);
r_netgraph = Cvar_Get ("r_netgraph","0",0,"None");
// Cvar_RegisterVariable (&r_zgraph);
r_zgraph = Cvar_Get ("r_zgraph","0",0,"None");
r_graphheight = Cvar_Get ("r_graphheight","15",0,"None");
#endif // QUAKEWORLD
Cvar_RegisterVariable (&r_graphheight);
Cvar_RegisterVariable (&r_drawflat);
Cvar_RegisterVariable (&r_ambient);
Cvar_RegisterVariable (&r_clearcolor);
Cvar_RegisterVariable (&r_waterwarp);
Cvar_RegisterVariable (&r_fullbright);
Cvar_RegisterVariable (&r_drawentities);
Cvar_RegisterVariable (&r_drawviewmodel);
Cvar_RegisterVariable (&r_aliasstats);
Cvar_RegisterVariable (&r_dspeeds);
Cvar_RegisterVariable (&r_reportsurfout);
Cvar_RegisterVariable (&r_maxsurfs);
Cvar_RegisterVariable (&r_numsurfs);
Cvar_RegisterVariable (&r_reportedgeout);
Cvar_RegisterVariable (&r_maxedges);
Cvar_RegisterVariable (&r_numedges);
Cvar_RegisterVariable (&r_aliastransbase);
Cvar_RegisterVariable (&r_aliastransadj);
// Cvar_RegisterVariable (&r_graphheight);
r_graphheight = Cvar_Get ("r_graphheight","10",0,"None");
// Cvar_RegisterVariable (&r_drawflat);
r_drawflat = Cvar_Get ("r_drawflat","0",0,"None");
// Cvar_RegisterVariable (&r_ambient);
r_ambient = Cvar_Get ("r_ambient","0",0,"None");
// Cvar_RegisterVariable (&r_clearcolor);
r_clearcolor = Cvar_Get ("r_clearcolor", "2",0,"None");
// Cvar_RegisterVariable (&r_waterwarp);
r_waterwarp = Cvar_Get ("r_waterwarp","1",0,"None");
// Cvar_RegisterVariable (&r_fullbright);
r_fullbright = Cvar_Get ("r_fullbright","0",0,"None");
// Cvar_RegisterVariable (&r_drawentities);
r_drawentities = Cvar_Get ("r_drawentities","1",0,"None");
// Cvar_RegisterVariable (&r_drawviewmodel);
r_drawviewmodel = Cvar_Get ("r_drawviewmodel","1",0,"None");
// Cvar_RegisterVariable (&r_aliasstats);
r_aliasstats = Cvar_Get ("r_polymodelstats","0",0,"None");
// Cvar_RegisterVariable (&r_dspeeds);
r_dspeeds = Cvar_Get ("r_dspeeds","0",0,"None");
// Cvar_RegisterVariable (&r_reportsurfout);
r_reportsurfout = Cvar_Get ("r_reportsurfout","0",0,"None");
// Cvar_RegisterVariable (&r_maxsurfs);
r_maxsurfs = Cvar_Get ("r_maxsurfs","0",0,"None");
// Cvar_RegisterVariable (&r_numsurfs);
r_numsurfs = Cvar_Get ("r_numsurfs","0",0,"None");
// Cvar_RegisterVariable (&r_reportedgeout,"0");
r_reportedgeout = Cvar_Get ("r_reportedgeout","0",0,"None");
// Cvar_RegisterVariable (&r_maxedges);
r_maxedges = Cvar_Get ("r_maxedges","0",0,"None");
// Cvar_RegisterVariable (&r_numedges);
r_numedges = Cvar_Get ("r_numedges","0",0,"None");
// Cvar_RegisterVariable (&r_aliastransbase);
r_aliastransbase = Cvar_Get ("r_aliastransbase","200",0,"None");
// Cvar_RegisterVariable (&r_aliastransadj);
r_aliastransadj = Cvar_Get ("r_aliastransadj","100",0,"None");
Cvar_SetValue ("r_maxedges", (float)NUMSTACKEDGES);
Cvar_SetValue ("r_maxsurfs", (float)NUMSTACKSURFACES);
r_maxedges->value = (float)NUMSTACKEDGES;
r_maxsurfs->value = (float)NUMSTACKSURFACES;
view_clipplanes[0].leftedge = true;
view_clipplanes[1].rightedge = true;
@ -294,7 +342,7 @@ void R_NewMap (void)
r_viewleaf = NULL;
R_ClearParticles ();
r_cnumsurfs = r_maxsurfs.value;
r_cnumsurfs = r_maxsurfs->value;
if (r_cnumsurfs <= MINSURFACES)
r_cnumsurfs = MINSURFACES;
@ -318,7 +366,7 @@ void R_NewMap (void)
r_maxedgesseen = 0;
r_maxsurfsseen = 0;
r_numallocatededges = r_maxedges.value;
r_numallocatededges = r_maxedges->value;
if (r_numallocatededges < MINEDGES)
r_numallocatededges = MINEDGES;
@ -353,11 +401,11 @@ void R_SetVrect (vrect_t *pvrectin, vrect_t *pvrect, int lineadj)
float size;
qboolean full = false;
if (scr_viewsize.value >= 100.0) {
if (scr_viewsize->value >= 100.0) {
size = 100.0;
full = true;
} else
size = scr_viewsize.value;
size = scr_viewsize->value;
if (cl.intermission)
{
@ -367,12 +415,12 @@ void R_SetVrect (vrect_t *pvrectin, vrect_t *pvrect, int lineadj)
}
size /= 100.0;
if (!cl_sbar.value && full)
if (!cl_sbar->value && full)
h = pvrectin->height;
else
h = pvrectin->height - lineadj;
// h = (!cl_sbar.value && size==1.0) ? pvrectin->height : (pvrectin->height - lineadj);
// h = (!cl_sbar->value && size==1.0) ? pvrectin->height : (pvrectin->height - lineadj);
// h = pvrectin->height - lineadj;
if (full)
pvrect->width = pvrectin->width;
@ -385,7 +433,7 @@ void R_SetVrect (vrect_t *pvrectin, vrect_t *pvrect, int lineadj)
}
pvrect->width &= ~7;
pvrect->height = pvrectin->height * size;
if (cl_sbar.value || !full) {
if (cl_sbar->value || !full) {
if (pvrect->height > pvrectin->height - lineadj)
pvrect->height = pvrectin->height - lineadj;
} else
@ -399,7 +447,7 @@ void R_SetVrect (vrect_t *pvrectin, vrect_t *pvrect, int lineadj)
pvrect->y = 0;
else
pvrect->y = (h - pvrect->height)/2;
if ( lcd_x.value ) {
if ( lcd_x->value ) {
pvrect->y >>= 1;
pvrect->height >>=1;
}
@ -511,10 +559,10 @@ void R_ViewChanged (vrect_t *pvrect, int lineadj, float aspect)
res_scale = sqrt ((double)(r_refdef.vrect.width * r_refdef.vrect.height) /
(320.0 * 152.0)) *
(2.0 / r_refdef.horizontalFieldOfView);
r_aliastransition = r_aliastransbase.value * res_scale;
r_resfudge = r_aliastransadj.value * res_scale;
r_aliastransition = r_aliastransbase->value * res_scale;
r_resfudge = r_aliastransadj->value * res_scale;
if (scr_fov.value <= 90.0)
if (scr_fov->value <= 90.0)
r_fov_greater_than_90 = false;
else
r_fov_greater_than_90 = true;
@ -592,7 +640,7 @@ void R_DrawEntitiesOnList (void)
vec3_t dist;
float add;
if (!r_drawentities.value)
if (!r_drawentities->value)
return;
for (i=0 ; i<cl_numvisedicts ; i++)
@ -673,9 +721,9 @@ void R_DrawViewModel (void)
dlight_t *dl;
#ifdef QUAKEWORLD
if (!r_drawviewmodel.value || r_fov_greater_than_90 || !Cam_DrawViewModel())
if (!r_drawviewmodel->value || r_fov_greater_than_90 || !Cam_DrawViewModel())
#else
if (!r_drawviewmodel.value || r_fov_greater_than_90)
if (!r_drawviewmodel->value || r_fov_greater_than_90)
#endif // QUAKEWORLD
return;
@ -815,7 +863,7 @@ void R_DrawBEntitiesOnList (void)
model_t *clmodel;
float minmaxs[6];
if (!r_drawentities.value)
if (!r_drawentities->value)
return;
VectorCopy (modelorg, oldorigin);
@ -970,7 +1018,7 @@ void R_EdgeDrawing (void)
R_BeginEdgeFrame ();
if (r_dspeeds.value)
if (r_dspeeds->value)
{
rw_time1 = Sys_DoubleTime ();
}
@ -984,7 +1032,7 @@ void R_EdgeDrawing (void)
// z writes, so have the driver turn z compares on now
D_TurnZOn ();
if (r_dspeeds.value)
if (r_dspeeds->value)
{
rw_time2 = Sys_DoubleTime ();
db_time1 = rw_time2;
@ -992,13 +1040,13 @@ void R_EdgeDrawing (void)
R_DrawBEntitiesOnList ();
if (r_dspeeds.value)
if (r_dspeeds->value)
{
db_time2 = Sys_DoubleTime ();
se_time1 = db_time2;
}
if (!r_dspeeds.value)
if (!r_dspeeds->value)
{
VID_UnlockBuffer ();
S_ExtraUpdate (); // don't let sound get messed up if going slow
@ -1023,7 +1071,7 @@ void R_RenderView_ (void)
r_warpbuffer = warpbuffer;
if (r_timegraph.value || r_speeds.value || r_dspeeds.value)
if (r_timegraph->value || r_speeds->value || r_dspeeds->value)
r_time1 = Sys_DoubleTime ();
R_SetupFrame ();
@ -1047,7 +1095,7 @@ SetVisibilityByPassages ();
#endif // QUAKEWORLD
Sys_Error ("R_RenderView: NULL worldmodel");
if (!r_dspeeds.value)
if (!r_dspeeds->value)
{
VID_UnlockBuffer ();
S_ExtraUpdate (); // don't let sound get messed up if going slow
@ -1056,14 +1104,14 @@ SetVisibilityByPassages ();
R_EdgeDrawing ();
if (!r_dspeeds.value)
if (!r_dspeeds->value)
{
VID_UnlockBuffer ();
S_ExtraUpdate (); // don't let sound get messed up if going slow
VID_LockBuffer ();
}
if (r_dspeeds.value)
if (r_dspeeds->value)
{
se_time2 = Sys_DoubleTime ();
de_time1 = se_time2;
@ -1071,7 +1119,7 @@ SetVisibilityByPassages ();
R_DrawEntitiesOnList ();
if (r_dspeeds.value)
if (r_dspeeds->value)
{
de_time2 = Sys_DoubleTime ();
dv_time1 = de_time2;
@ -1079,7 +1127,7 @@ SetVisibilityByPassages ();
R_DrawViewModel ();
if (r_dspeeds.value)
if (r_dspeeds->value)
{
dv_time2 = Sys_DoubleTime ();
dp_time1 = Sys_DoubleTime ();
@ -1087,7 +1135,7 @@ SetVisibilityByPassages ();
R_DrawParticles ();
if (r_dspeeds.value)
if (r_dspeeds->value)
dp_time2 = Sys_DoubleTime ();
if (r_dowarp)
@ -1095,30 +1143,30 @@ SetVisibilityByPassages ();
V_SetContentsColor (r_viewleaf->contents);
if (r_timegraph.value)
if (r_timegraph->value)
R_TimeGraph ();
#ifdef QUAKEWORLD
if (r_netgraph.value)
if (r_netgraph->value)
R_NetGraph ();
if (r_zgraph.value)
if (r_zgraph->value)
R_ZGraph ();
#endif // QUAKEWORLD
if (r_aliasstats.value)
if (r_aliasstats->value)
R_PrintAliasStats ();
if (r_speeds.value)
if (r_speeds->value)
R_PrintTimes ();
if (r_dspeeds.value)
if (r_dspeeds->value)
R_PrintDSpeeds ();
if (r_reportsurfout.value && r_outofsurfaces)
if (r_reportsurfout->value && r_outofsurfaces)
Con_Printf ("Short %d surfaces\n", r_outofsurfaces);
if (r_reportedgeout.value && r_outofedges)
if (r_reportedgeout->value && r_outofedges)
Con_Printf ("Short roughly %d edges\n", r_outofedges * 2 / 3);
// back to high floating-point precision

32
common/r_misc.c
View file

@ -46,9 +46,9 @@ void R_CheckVariables (void)
#ifdef UQUAKE
static float oldbright;
if (r_fullbright.value != oldbright)
if (r_fullbright->value != oldbright)
{
oldbright = r_fullbright.value;
oldbright = r_fullbright->value;
D_FlushCaches (); // so all lighting changes
}
#endif
@ -135,7 +135,7 @@ void R_LineGraph (int x, int y, int h)
#endif
dest = vid.buffer + vid.rowbytes*y + x;
s = r_graphheight.value;
s = r_graphheight->value;
if (h == 10000)
color = 0x6f; // yellow
@ -187,7 +187,7 @@ void R_TimeGraph (void)
a = (r_time2-r_time1)/0.01;
//a = fabs(mouse_y * 0.05);
//a = (int)((r_refdef.vieworg[2] + 1024)/1)%(int)r_graphheight.value;
//a = (int)((r_refdef.vieworg[2] + 1024)/1)%(int)r_graphheight->value;
//a = (int)((pmove.velocity[2] + 500)/10);
//a = fabs(velocity[0])/20;
//a = ((int)fabs(origin[0])/8)%20;
@ -235,9 +235,9 @@ void R_NetGraph (void)
w = NET_TIMINGS;
x = -((vid.width - 320)>>1);
y = vid.height - sb_lines - 24 - (int)r_graphheight.value*2 - 2;
y = vid.height - sb_lines - 24 - (int)r_graphheight->value*2 - 2;
M_DrawTextBox (x, y, (w+7)/8, ((int)r_graphheight.value*2+7)/8 + 1);
M_DrawTextBox (x, y, (w+7)/8, ((int)r_graphheight->value*2+7)/8 + 1);
y2 = y + 8;
y = vid.height - sb_lines - 8 - 2;
@ -465,13 +465,13 @@ void R_SetupFrame (void)
// don't allow cheats in multiplayer
if (cl.maxclients > 1)
{
r_draworder.value = 0;
r_fullbright.value = 0;
r_ambient.value = 0;
r_drawflat.value = 0;
r_draworder->value = 0;
r_fullbright->value = 0;
r_ambient->value = 0;
r_drawflat->value = 0;
}
if (r_numsurfs.value)
if (r_numsurfs->value)
{
if ((surface_p - surfaces) > r_maxsurfsseen)
r_maxsurfsseen = surface_p - surfaces;
@ -480,7 +480,7 @@ void R_SetupFrame (void)
surf_max - surfaces, r_maxsurfsseen);
}
if (r_numedges.value)
if (r_numedges->value)
{
edgecount = edge_p - r_edges;
@ -491,14 +491,14 @@ void R_SetupFrame (void)
r_numallocatededges, r_maxedgesseen);
}
r_refdef.ambientlight = r_ambient.value;
r_refdef.ambientlight = r_ambient->value;
if (r_refdef.ambientlight < 0)
r_refdef.ambientlight = 0;
#ifdef UQUAKE
if (!sv.active)
#endif
r_draworder.value = 0; // don't let cheaters look behind walls
r_draworder->value = 0; // don't let cheaters look behind walls
R_CheckVariables ();
@ -529,11 +529,11 @@ r_refdef.viewangles[2]= 0;
r_viewleaf = Mod_PointInLeaf (r_origin, cl.worldmodel);
r_dowarpold = r_dowarp;
r_dowarp = r_waterwarp.value && (r_viewleaf->contents <= CONTENTS_WATER);
r_dowarp = r_waterwarp->value && (r_viewleaf->contents <= CONTENTS_WATER);
if ((r_dowarp != r_dowarpold)
#ifdef UQUAKE
|| lcd_x.value
|| lcd_x->value
#endif
|| r_viewchanged)
{

2
common/r_shared.h
View file

@ -56,7 +56,7 @@ extern float pixelAspect;
extern int r_drawnpolycount;
extern cvar_t r_clearcolor;
extern cvar_t *r_clearcolor;
extern int sintable[SIN_BUFFER_SIZE];
extern int intsintable[SIN_BUFFER_SIZE];

2
common/r_surf.c
View file

@ -168,7 +168,7 @@ void R_BuildLightMap (void)
size = smax*tmax;
lightmap = surf->samples;
if (r_fullbright.value || !cl.worldmodel->lightdata)
if (r_fullbright->value || !cl.worldmodel->lightdata)
{
for (i=0 ; i<size ; i++)
blocklights[i] = 0;

6
common/register_check.c
View file

@ -33,7 +33,8 @@
#include "quakefs.h"
#include "quakedef.h"
cvar_t registered = {"registered", "0"};
//cvar_t registered = {"registered", "0"};
cvar_t *registered;
/*
register_check
@ -46,7 +47,8 @@ register_check ( void ) {
QFile *h;
Cvar_RegisterVariable (&registered);
// Cvar_RegisterVariable (&registered);
registered = Cvar_Get ("registered","0",0,"None");
COM_FOpenFile("gfx/pop.lmp", &h);

2
common/register_check.h
View file

@ -23,7 +23,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#ifndef _REGISTER_CHECK_H
#define _REGISTER_CHECK_H
extern struct cvar_s registered;
extern struct cvar_s *registered;
void register_check ();
#endif // _REGISTER_CHECK_H

30
common/sbar.c
View file

@ -341,7 +341,7 @@ Sbar_DrawPic
void Sbar_DrawPic (int x, int y, qpic_t *pic)
{
#ifdef UQUAKE
if ((cl_sbar.value && !cl.gametype == GAME_DEATHMATCH)
if ((cl_sbar->value && !cl.gametype == GAME_DEATHMATCH)
&& (hipnotic || rogue))
Draw_Pic (x + ((vid.width - 320)>>1),
y + (vid.height-SBAR_HEIGHT), pic);
@ -360,7 +360,7 @@ void Sbar_DrawSubPic(int x, int y, qpic_t *pic,
int srcx, int srcy, int width, int height)
{
#ifdef UQUAKE
if ((cl_sbar.value && !cl.gametype == GAME_DEATHMATCH)
if ((cl_sbar->value && !cl.gametype == GAME_DEATHMATCH)
&& (hipnotic || rogue))
Draw_SubPic (x + ((vid.width - 320)>>1),
y + (vid.height-SBAR_HEIGHT),
@ -380,7 +380,7 @@ Sbar_DrawTransPic
void Sbar_DrawTransPic (int x, int y, qpic_t *pic)
{
#ifdef UQUAKE
if ((cl_sbar.value && !cl.gametype == GAME_DEATHMATCH)
if ((cl_sbar->value && !cl.gametype == GAME_DEATHMATCH)
&& (hipnotic || rogue))
Draw_TransPic (x + ((vid.width - 320)>>1),
y + (vid.height-SBAR_HEIGHT), pic);
@ -399,7 +399,7 @@ Draws one solid graphics character
void Sbar_DrawCharacter (int x, int y, int num)
{
#ifdef UQUAKE
if ((cl_sbar.value && !cl.gametype == GAME_DEATHMATCH)
if ((cl_sbar->value && !cl.gametype == GAME_DEATHMATCH)
&& (hipnotic || rogue))
Draw_Character (x + ((vid.width - 320)>>1) + 4,
y + (vid.height-SBAR_HEIGHT), num);
@ -416,7 +416,7 @@ Sbar_DrawString
void Sbar_DrawString (int x, int y, char *str)
{
#ifdef UQUAKE
if ((cl_sbar.value && !cl.gametype == GAME_DEATHMATCH)
if ((cl_sbar->value && !cl.gametype == GAME_DEATHMATCH)
&& (hipnotic || rogue))
Draw_String (x + ((vid.width - 320)>>1),
y + (vid.height-SBAR_HEIGHT), str);
@ -715,11 +715,11 @@ void Sbar_DrawInventory (void)
char num[6];
float time;
int flashon;
qboolean headsup;
qboolean hudswap;
qboolean headsup = false;
qboolean hudswap = false;
headsup = !(cl_sbar.value || scr_viewsize.value<100);
hudswap = cl_hudswap.value; // Get that nasty float out :)
headsup = !(cl_sbar->value || (scr_viewsize->value < 100));
hudswap = cl_hudswap->value; // Get that nasty float out :)
#ifdef UQUAKE
if (hipnotic)
@ -949,7 +949,7 @@ void Sbar_DrawFrags (void)
l = scoreboardlines <= 4 ? scoreboardlines : 4;
x = 23;
if (cl.gametype == GAME_DEATHMATCH || cl_sbar.value == 0)
if (cl.gametype == GAME_DEATHMATCH || cl_sbar->value == 0)
xofs = 0;
else
xofs = (vid.width - 320)>>1;
@ -1017,8 +1017,8 @@ void Sbar_DrawFace (void)
// PGM 03/02/97 - fixed so color swatch only appears in CTF modes
if (rogue &&
(cl.maxclients != 1) &&
(teamplay.value>3) &&
(teamplay.value<7)) {
(teamplay->value>3) &&
(teamplay->value<7)) {
int top, bottom;
int xofs;
char num[12];
@ -1107,7 +1107,7 @@ Sbar_DrawNormal
*/
void Sbar_DrawNormal (void)
{
if (cl_sbar.value || scr_viewsize.value<100)
if (cl_sbar->value || scr_viewsize->value<100)
Sbar_DrawPic (0, 0, sb_sbar);
#ifdef UQUAKE
@ -1197,12 +1197,12 @@ Sbar_Draw
*/
void Sbar_Draw (void)
{
qboolean headsup;
qboolean headsup = false;
#ifdef QUAKEWORLD
char st[512];
#endif
headsup = !(cl_sbar.value || scr_viewsize.value<100);
headsup = !(cl_sbar->value || scr_viewsize->value<100);
if ((sb_updates >= vid.numpages) && !headsup)
return;

30
common/server.h
View file

@ -390,12 +390,12 @@ typedef struct
//============================================================================
extern cvar_t teamplay;
extern cvar_t skill;
extern cvar_t deathmatch;
extern cvar_t coop;
extern cvar_t fraglimit;
extern cvar_t timelimit;
extern cvar_t *teamplay;
extern cvar_t *skill;
extern cvar_t *deathmatch;
extern cvar_t *coop;
extern cvar_t *fraglimit;
extern cvar_t *timelimit;
extern server_static_t svs; // persistant server info
extern server_t sv; // local server
@ -407,8 +407,8 @@ extern jmp_buf host_abortserver;
extern double host_time;
extern edict_t *sv_player;
extern cvar_t sv_mintic, sv_maxtic;
extern cvar_t sv_maxspeed;
extern cvar_t *sv_mintic, *sv_maxtic;
extern cvar_t *sv_maxspeed;
#ifdef QUAKEWORLD
extern netadr_t master_adr[MAX_MASTERS]; // address of the master server
@ -416,11 +416,11 @@ extern netadr_t master_adr[MAX_MASTERS]; // address of the master server
extern netadr_t master_adr; // address of the master server
#endif
extern cvar_t spawn;
extern cvar_t teamplay;
extern cvar_t deathmatch;
extern cvar_t fraglimit;
extern cvar_t timelimit;
extern cvar_t *spawn;
extern cvar_t *teamplay;
extern cvar_t *deathmatch;
extern cvar_t *fraglimit;
extern cvar_t *timelimit;
extern server_static_t svs; // persistant server info
extern server_t sv; // local server
@ -545,8 +545,8 @@ void ClientReliableWrite_SZ(client_t *cl, void *data, int len);
//
extern quakeparms_t host_parms;
extern cvar_t sys_nostdout;
extern cvar_t developer;
extern cvar_t *sys_nostdout;
extern cvar_t *developer;
extern qboolean host_initialized; // true if into command execution
extern double host_frametime;

14
common/skin.c
View file

@ -28,8 +28,10 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "console.h"
#include "client.h"
cvar_t baseskin = {"baseskin", "base"};
cvar_t noskins = {"noskins", "0"};
//cvar_t baseskin = {"baseskin", "base"};
cvar_t *baseskin;
//cvar_t noskins = {"noskins", "0"};
cvar_t *noskins;
char allskins[128];
#define MAX_CACHED_SKINS 128
@ -59,7 +61,7 @@ void Skin_Find (player_info_t *sc)
if (s && s[0])
strcpy (name, s);
else
strcpy (name, baseskin.string);
strcpy (name, baseskin->string);
}
if (strstr (name, "..") || *name == '.')
@ -112,7 +114,7 @@ byte *Skin_Cache (skin_t *skin)
if (cls.downloadtype == dl_skin)
return NULL; // use base until downloaded
if (noskins.value==1) // JACK: So NOSKINS > 1 will show skins, but
if (noskins->value==1) // JACK: So NOSKINS > 1 will show skins, but
return NULL; // not download new ones.
if (skin->failedload)
@ -130,7 +132,7 @@ byte *Skin_Cache (skin_t *skin)
if (!raw)
{
Con_Printf ("Couldn't load skin %s\n", name);
snprintf(name, sizeof(name), "skins/%s.pcx", baseskin.string);
snprintf(name, sizeof(name), "skins/%s.pcx", baseskin->string);
raw = COM_LoadTempFile (name);
if (!raw)
{
@ -241,7 +243,7 @@ void Skin_NextDownload (void)
if (!sc->name[0])
continue;
Skin_Find (sc);
if (noskins.value)
if (noskins->value)
continue;
#ifndef UQUAKE
if (!CL_CheckOrDownloadFile(va("skins/%s.pcx", sc->skin->name)))

88
common/snd_dma.c
View file

@ -82,18 +82,29 @@ int desired_bits = 16;
int sound_started=0;
cvar_t bgmvolume = {"bgmvolume", "1", CVAR_ARCHIVE};
cvar_t volume = {"volume", "0.7", CVAR_ARCHIVE};
//cvar_t bgmvolume = {"bgmvolume", "1", CVAR_ARCHIVE};
cvar_t *bgmvolume;
//cvar_t volume = {"volume", "0.7", CVAR_ARCHIVE};
cvar_t *volume;
cvar_t nosound = {"nosound", "0"};
cvar_t precache = {"precache", "1"};
cvar_t loadas8bit = {"loadas8bit", "0"};
cvar_t bgmbuffer = {"bgmbuffer", "4096"};
cvar_t ambient_level = {"ambient_level", "0.3"};
cvar_t ambient_fade = {"ambient_fade", "100"};
cvar_t snd_noextraupdate = {"snd_noextraupdate", "0"};
cvar_t snd_show = {"snd_show", "0"};
cvar_t _snd_mixahead = {"_snd_mixahead", "0.1", CVAR_ARCHIVE};
//cvar_t nosound = {"nosound", "0"};
cvar_t *nosound;
//cvar_t precache = {"precache", "1"};
cvar_t *precache;
//cvar_t loadas8bit = {"loadas8bit", "0"};
cvar_t *loadas8bit;
//cvar_t bgmbuffer = {"bgmbuffer", "4096"};
cvar_t *bgmbuffer;
//cvar_t ambient_level = {"ambient_level", "0.3"};
cvar_t *ambient_level;
//cvar_t ambient_fade = {"ambient_fade", "100"};
cvar_t *ambient_fade;
//cvar_t snd_noextraupdate = {"snd_noextraupdate", "0"};
cvar_t *snd_noextraupdate;
//cvar_t snd_show = {"snd_show", "0"};
cvar_t *snd_show;
//cvar_t _snd_mixahead = {"_snd_mixahead", "0.1", CVAR_ARCHIVE};
cvar_t *_snd_mixahead;
// ====================================================================
@ -195,17 +206,28 @@ void S_Init (void)
Cmd_AddCommand("soundlist", S_SoundList);
Cmd_AddCommand("soundinfo", S_SoundInfo_f);
Cvar_RegisterVariable(&nosound);
Cvar_RegisterVariable(&volume);
Cvar_RegisterVariable(&precache);
Cvar_RegisterVariable(&loadas8bit);
Cvar_RegisterVariable(&bgmvolume);
Cvar_RegisterVariable(&bgmbuffer);
Cvar_RegisterVariable(&ambient_level);
Cvar_RegisterVariable(&ambient_fade);
Cvar_RegisterVariable(&snd_noextraupdate);
Cvar_RegisterVariable(&snd_show);
Cvar_RegisterVariable(&_snd_mixahead);
// Cvar_RegisterVariable(&nosound);
nosound = Cvar_Get ("nosound","0",CVAR_NONE,"None");
// Cvar_RegisterVariable(&volume);
volume = Cvar_Get ("volume","0.7",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable(&precache);
precache = Cvar_Get ("precache","1",0,"None");
// Cvar_RegisterVariable(&loadas8bit);
loadas8bit = Cvar_Get ("loadas8bit","0",0,"None");
// Cvar_RegisterVariable(&bgmvolume);
bgmvolume = Cvar_Get ("bgmvolume","1",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable(&bgmbuffer);
bgmbuffer = Cvar_Get ("bgmbuffer","4096",0,"None");
// Cvar_RegisterVariable(&ambient_level);
ambient_level = Cvar_Get ("ambient_level","0.3",0,"None");
// Cvar_RegisterVariable(&ambient_fade);
ambient_fade = Cvar_Get ("ambient_fade","100",0,"None");
// Cvar_RegisterVariable(&snd_noextraupdate);
snd_noextraupdate = Cvar_Get ("snd_noextraupdate","0",0,"None");
// Cvar_RegisterVariable(&snd_show);
snd_show = Cvar_Get ("snd_show","0",0,"None");
// Cvar_RegisterVariable(&_snd_mixahead);
_snd_mixahead = Cvar_Get ("_snd_mixahead","0.1",CVAR_ARCHIVE,"None");
if (host_parms.memsize < 0x800000)
{
@ -348,13 +370,13 @@ sfx_t *S_PrecacheSound (char *name)
{
sfx_t *sfx;
if (!sound_started || nosound.value)
if (!sound_started || nosound->value)
return NULL;
sfx = S_FindName (name);
// cache it in
if (precache.value)
if (precache->value)
S_LoadSound (sfx);
return sfx;
@ -480,7 +502,7 @@ void S_StartSound(int entnum, int entchannel, sfx_t *sfx, vec3_t origin, float f
if (!sfx)
return;
if (nosound.value)
if (nosound->value)
return;
vol = fvol*255;
@ -694,7 +716,7 @@ void S_UpdateAmbientSounds (void)
return;
l = Mod_PointInLeaf (listener_origin, cl.worldmodel);
if (!l || !ambient_level.value)
if (!l || !ambient_level->value)
{
for (ambient_channel = 0 ; ambient_channel< NUM_AMBIENTS ; ambient_channel++)
channels[ambient_channel].sfx = NULL;
@ -706,20 +728,20 @@ void S_UpdateAmbientSounds (void)
chan = &channels[ambient_channel];
chan->sfx = ambient_sfx[ambient_channel];
vol = ambient_level.value * l->ambient_sound_level[ambient_channel];
vol = ambient_level->value * l->ambient_sound_level[ambient_channel];
if (vol < 8)
vol = 0;
// don't adjust volume too fast
if (chan->master_vol < vol)
{
chan->master_vol += host_frametime * ambient_fade.value;
chan->master_vol += host_frametime * ambient_fade->value;
if (chan->master_vol > vol)
chan->master_vol = vol;
}
else if (chan->master_vol > vol)
{
chan->master_vol -= host_frametime * ambient_fade.value;
chan->master_vol -= host_frametime * ambient_fade->value;
if (chan->master_vol < vol)
chan->master_vol = vol;
}
@ -807,7 +829,7 @@ void S_Update(vec3_t origin, vec3_t forward, vec3_t right, vec3_t up)
//
// debugging output
//
if (snd_show.value)
if (snd_show->value)
{
total = 0;
ch = channels;
@ -867,7 +889,7 @@ void S_ExtraUpdate (void)
IN_Accumulate ();
#endif
if (snd_noextraupdate.value)
if (snd_noextraupdate->value)
return; // don't pollute timings
S_Update_();
}
@ -891,7 +913,7 @@ void S_Update_(void)
}
// mix ahead of current position
endtime = soundtime + _snd_mixahead.value * shm->speed;
endtime = soundtime + _snd_mixahead->value * shm->speed;
samps = shm->samples >> (shm->channels-1);
if (endtime - soundtime > samps)
endtime = soundtime + samps;
@ -1005,7 +1027,7 @@ void S_LocalSound (char *sound)
{
sfx_t *sfx;
if (nosound.value)
if (nosound->value)
return;
if (!sound_started)
return;

2
common/snd_mem.c
View file

@ -60,7 +60,7 @@ void ResampleSfx (sfx_t *sfx, int inrate, int inwidth, byte *data)
sc->loopstart = sc->loopstart / stepscale;
sc->speed = shm->speed;
if (loadas8bit.value)
if (loadas8bit->value)
sc->width = 1;
else
sc->width = inwidth;

4
common/snd_mix.c
View file

@ -86,7 +86,7 @@ void S_TransferStereo16 (int endtime)
HRESULT hresult;
#endif
snd_vol = volume.value*256;
snd_vol = volume->value*256;
snd_p = (int *) paintbuffer;
lpaintedtime = paintedtime;
@ -176,7 +176,7 @@ void S_TransferPaintBuffer(int endtime)
out_mask = shm->samples - 1;
out_idx = paintedtime * shm->channels & out_mask;
step = 3 - shm->channels;
snd_vol = volume.value*256;
snd_vol = volume->value*256;
#ifdef _WIN32
if (pDSBuf)

9
common/snd_null.c
View file

@ -34,12 +34,15 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
channel_t channels[MAX_CHANNELS];
int total_channels;
volatile dma_t *shm = 0;
cvar_t loadas8bit = {"loadas8bit", "0"};
//cvar_t loadas8bit = {"loadas8bit", "0"};
cvar_t *loadas8bit;
int paintedtime; // sample PAIRS
cvar_t bgmvolume = {"bgmvolume", "1", true};
cvar_t volume = {"volume", "0.7", true};
//cvar_t bgmvolume = {"bgmvolume", "1", true};
cvar_t *bgmvolume;
//cvar_t volume = {"volume", "0.7", true};
cvar_t *volume;
void S_Init (void)

6
common/sound.h
View file

@ -167,9 +167,9 @@ extern volatile dma_t *shm;
extern volatile dma_t sn;
extern vec_t sound_nominal_clip_dist;
extern cvar_t loadas8bit;
extern cvar_t bgmvolume;
extern cvar_t volume;
extern cvar_t *loadas8bit;
extern cvar_t *bgmvolume;
extern cvar_t *volume;
extern qboolean snd_initialized;

4
common/sw_rpart.c
View file

@ -35,7 +35,7 @@ extern int ramp1[8], ramp2[8], ramp3[8];
R_DrawParticles
===============
*/
extern cvar_t sv_gravity;
extern cvar_t *sv_gravity;
void R_DrawParticles (void)
{
particle_t *p, *kill;
@ -63,7 +63,7 @@ void R_DrawParticles (void)
#ifdef QUAKEWORLD
grav = frametime * 800 * 0.05;
#else
grav = frametime * sv_gravity.value * 0.05;
grav = frametime * sv_gravity->value * 0.05;
#endif
dvel = 4*frametime;

5
common/sys_common.c
View file

@ -43,7 +43,8 @@
int nostdout = 0;
cvar_t sys_nostdout = {"sys_nostdout","0"};
//cvar_t sys_nostdout = {"sys_nostdout","0"};
cvar_t *sys_nostdout;
char trans_table[256] = {
@ -78,7 +79,7 @@ void Sys_Printf (char *fmt, ...)
char text[2048];
unsigned char *p;
if (nostdout || sys_nostdout.value) return;
// if (nostdout || sys_nostdout->value) return;
va_start(argptr, fmt);
vsnprintf(text, sizeof(text), fmt, argptr);

11
common/sys_linux.c
View file

@ -60,7 +60,8 @@ int noconinput = 0;
char *basedir = ".";
char *cachedir = "/tmp";
cvar_t sys_linerefresh = {"sys_linerefresh","0"};// set for entity display
//cvar_t sys_linerefresh = {"sys_linerefresh","0"};// set for entity display
cvar_t *sys_linerefresh;
// =======================================================================
// General routines
@ -323,13 +324,13 @@ int main (int c, char **v) {
#ifdef UQUAKE
if (cls.state == ca_dedicated) { // play vcrfiles at max speed
if (time < sys_ticrate.value && (vcrFile == -1 || recording) ) {
if (time < sys_ticrate->value && (vcrFile == -1 || recording) ) {
usleep(1);
continue; // not time to run a server only tic yet
}
time = sys_ticrate.value;
time = sys_ticrate->value;
}
if (time > sys_ticrate.value*2)
if (time > sys_ticrate->value*2)
oldtime = newtime;
else
oldtime += time;
@ -338,7 +339,7 @@ int main (int c, char **v) {
#endif
Host_Frame(time);
// graphic debugging aids
if (sys_linerefresh.value)
if (sys_linerefresh->value)
Sys_LineRefresh ();
}
}

23
common/vid_aa.c
View file

@ -47,9 +47,12 @@ static byte vid_current_palette[768];
static int UseDisplay = 1;
static cvar_t vid_mode = {"vid_mode","5",CVAR_NONE};
static cvar_t vid_redrawfull = {"vid_redrawfull","0",CVAR_NONE};
static cvar_t vid_waitforrefresh = {"vid_waitforrefresh","0",CVAR_ARCHIVE};
//static cvar_t vid_mode = {"vid_mode","5",CVAR_NONE};
static cvar_t *vid_mode;
//static cvar_t vid_redrawfull = {"vid_redrawfull","0",CVAR_NONE};
static cvar_t *vid_redrawfull;
//static cvar_t vid_waitforrefresh = {"vid_waitforrefresh","0",CVAR_ARCHIVE};
static cvar_t *vid_waitforrefresh;
static char *framebuffer_ptr;
@ -387,9 +390,13 @@ VID_Init(unsigned char *palette)
if (UseDisplay) {
Cvar_RegisterVariable (&vid_mode);
Cvar_RegisterVariable (&vid_redrawfull);
Cvar_RegisterVariable (&vid_waitforrefresh);
// Cvar_RegisterVariable (&vid_mode);
vid_mode = Cvar_Get ("vid_mode","5");
// Cvar_RegisterVariable (&vid_redrawfull);
vid_redrawfull = Cvar_Get ("vid_redrawfull","0");
// Cvar_RegisterVariable (&vid_waitforrefresh);
vid_waitforrefresh = Cvar_Get ("vid_waitforrefresh","0",
CVAR_ARCHIVE);
Cmd_AddCommand("vid_nummodes", VID_NumModes_f);
Cmd_AddCommand("vid_describemode", VID_DescribeMode_f);
@ -464,8 +471,8 @@ VID_Update(vrect_t *rects)
}
}
if (vid_mode.value != current_mode) {
VID_SetMode ((int)vid_mode.value, vid_current_palette);
if (vid_mode->value != current_mode) {
VID_SetMode ((int)vid_mode->value, vid_current_palette);
}
}

81
common/vid_dos.c
View file

@ -44,6 +44,38 @@ vmode_t *pcurrentmode = NULL;
int vid_testingmode, vid_realmode;
double vid_testendtime;
<<<<<<< vid_dos.c
//cvar_t vid_mode = {"vid_mode","0", CVAR_NONE};
cvar_t *vid_mode;
//cvar_t vid_wait = {"vid_wait","0"};
cvar_t *vid_wait;
//cvar_t vid_nopageflip = {"vid_nopageflip","0", CVAR_ARCHIVE};
cvar_t *vid_nopageflip;
//cvar_t _vid_wait_override = {"_vid_wait_override", "0",CVAR_ARCHIVE};
cvar_t *_vid_wait_override;
//cvar_t _vid_default_mode = {"_vid_default_mode","0", CVAR_ARCHIVE};
cvar_t *_vid_default_mode;
//cvar_t _vid_default_mode_win = {"_vid_default_mode_win","1", CVAR_ARCHIVE};
cvar_t *_vid_default_mode_win;
//cvar_t vid_config_x = {"vid_config_x","800", CVAR_ARCHIVE};
cvar_t *vid_config_x;
//cvar_t vid_config_y = {"vid_config_y","600", CVAR_ARCHIVE};
cvar_t *vid_config_y;
//cvar_t vid_stretch_by_2 = {"vid_stretch_by_2","1", CVAR_ARCHIVE};
cvar_t *vid_stretch_by_2;
//cvar_t _windowed_mouse = {"_windowed_mouse","0", CVAR_ARCHIVE};
cvar_t *_windowed_mouse;
//cvar_t vid_fullscreen_mode = {"vid_fullscreen_mode","3", CVAR_ARCHIVE};
cvar_t *vid_fullscreen_mode;
//cvar_t vid_windowed_mode = {"vid_windowed_mode","0", CVAR_ARCHIVE};
cvar_t *vid_windowed_mode;
//cvar_t block_switch = {"block_switch","0", CVAR_ARCHIVE};
cvar_t *block_switch;
//cvar_t vid_window_x = {"vid_window_x", "0", CVAR_ARCHIVE};
cvar_t *vid_window_x;
//cvar_t vid_window_y = {"vid_window_y", "0", CVAR_ARCHIVE};
cvar_t *vid_window_y;
=======
cvar_t vid_mode = {"vid_mode","0", CVAR_NONE};
cvar_t vid_wait = {"vid_wait","0"};
cvar_t vid_nopageflip = {"vid_nopageflip","0", CVAR_ARCHIVE};
@ -58,6 +90,7 @@ cvar_t vid_windowed_mode = {"vid_windowed_mode","0", CVAR_ARCHIVE};
cvar_t block_switch = {"block_switch","0", CVAR_ARCHIVE};
cvar_t vid_window_x = {"vid_window_x", "0", CVAR_ARCHIVE};
cvar_t vid_window_y = {"vid_window_y", "0", CVAR_ARCHIVE};
>>>>>>> 1.15
int VID_options_items = 0;
@ -95,6 +128,35 @@ VID_Init
*/
void VID_Init (unsigned char *palette)
{
<<<<<<< vid_dos.c
// Cvar_RegisterVariable (&vid_mode);
vid_mode = Cvar_Get ("vid_mode","0");
// Cvar_RegisterVariable (&vid_wait);
vid_wait = Cvar_Get ("vid_mode","0");
// Cvar_RegisterVariable (&vid_nopageflip);
vid_nopageflip = Cvar_Get ("vid_nopageflip","0",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&_vid_wait_override);
_vid_wait_override = Cvar_Get ("_vid_wait_override","0",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&_vid_default_mode);
_vid_default_mode = Cvar_Get ("_vid_default_mode","0",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&_vid_default_mode_win);
_vid_default_mode_win = Cvar_Get ("_vid_default_mode_win","1",
CVAR_ARCHIVE);
// Cvar_RegisterVariable (&vid_config_x);
vid_config_x = Cvar_Get ("vid_config_x","800",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&vid_config_y);
vid_config_y = Cvar_Get ("vid_config_y","600",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&vid_stretch_by_2);
vid_stretch_by_2 = Cvar_Get ("vid_stretch_by_2","1",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&_windowed_mouse);
_windowed_mouse = Cvar_Get ("_windowed_mouse","0",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&vid_fullscreen_mode);
vid_fullscreen_mode = Cvar_Get ("vid_fullscreen_mode","3",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&vid_windowed_mode);
vid_windowed_mode = Cvar_Get ("vid_windowed_mode","0",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&block_switch);
block_switch = Cvar_Get ("block_switch","0",CVAR_ARCHIVE);
=======
Cvar_RegisterVariable (&vid_mode);
Cvar_RegisterVariable (&vid_wait);
Cvar_RegisterVariable (&vid_nopageflip);
@ -107,6 +169,7 @@ void VID_Init (unsigned char *palette)
Cvar_RegisterVariable (&vid_fullscreen_mode);
Cvar_RegisterVariable (&vid_windowed_mode);
Cvar_RegisterVariable (&block_switch);
>>>>>>> 1.15
Cmd_AddCommand ("vid_testmode", VID_TestMode_f);
Cmd_AddCommand ("vid_nummodes", VID_NumModes_f);
@ -123,7 +186,7 @@ void VID_Init (unsigned char *palette)
vid_testingmode = 0;
vid_modenum = vid_mode.value;
vid_modenum = vid_mode->value;
VID_SetMode (vid_modenum, palette);
@ -330,13 +393,13 @@ VID_Update
*/
void VID_Update (vrect_t *rects)
{
if (firstupdate && _vid_default_mode.value)
if (firstupdate && _vid_default_mode->value)
{
if(_vid_default_mode.value >= numvidmodes)
if(_vid_default_mode->value >= numvidmodes)
Cvar_SetValue ("_vid_default_mode", 0);
firstupdate = 0;
Cvar_SetValue ("vid_mode", _vid_default_mode.value);
Cvar_SetValue ("vid_mode", _vid_default_mode->value);
}
(*pcurrentmode->swapbuffers)(&vid, pcurrentmode, rects);
@ -353,9 +416,9 @@ void VID_Update (vrect_t *rects)
}
else
{
if (vid_mode.value != vid_realmode)
if (vid_mode->value != vid_realmode)
{
VID_SetMode ((int)vid_mode.value, vid_current_palette);
VID_SetMode ((int)vid_mode->value, vid_current_palette);
Cvar_SetValue ("vid_mode", (float)vid_modenum);
// so if mode set fails, we don't keep on
// trying to set that mode
@ -432,7 +495,7 @@ void VID_DescribeModes_f (void)
Con_Printf ("\n%s\n", pheader);
if (VGA_CheckAdequateMem (pv->width, pv->height, pv->rowbytes,
(pv->numpages == 1) || vid_nopageflip.value))
(pv->numpages == 1) || vid_nopageflip->value))
{
Con_Printf ("%2d: %s\n", i, pinfo);
}
@ -464,7 +527,7 @@ char *VID_GetModeDescription (int mode)
pinfo = VID_ModeInfo (mode, &pheader);
if (VGA_CheckAdequateMem (pv->width, pv->height, pv->rowbytes,
(pv->numpages == 1) || vid_nopageflip.value))
(pv->numpages == 1) || vid_nopageflip->value))
{
return pinfo;
}
@ -674,7 +737,7 @@ void VID_MenuDraw (void)
ptr = VID_GetModeDescription (vid_modenum);
snprintf(temp, sizeof(temp), "D to make %s the default", ptr);
M_Print (6*8, 36 + MAX_COLUMN_SIZE * 8 + 8*5, temp);
ptr = VID_GetModeDescription ((int)_vid_default_mode.value);
ptr = VID_GetModeDescription ((int)_vid_default_mode->value);
if (ptr)
{

12
common/vid_ext.c
View file

@ -593,7 +593,7 @@ int VID_ExtraInitMode (viddef_t *lvid, vmode_t *pcurrentmode)
pextra = pcurrentmode->pextradata;
if (vid_nopageflip.value)
if (vid_nopageflip->value)
lvid->numpages = 1;
else
lvid->numpages = pcurrentmode->numpages;
@ -634,7 +634,7 @@ int VID_ExtraInitMode (viddef_t *lvid, vmode_t *pcurrentmode)
if (!pextra->vga_incompatible &&
(lvid->numpages == 3) &&
de_exists &&
(_vid_wait_override.value == 0.0))
(_vid_wait_override->value == 0.0))
{
Cvar_SetValue ("vid_wait", (float)VID_WAIT_DISPLAY_ENABLE);
@ -643,7 +643,7 @@ int VID_ExtraInitMode (viddef_t *lvid, vmode_t *pcurrentmode)
}
else
{
if ((lvid->numpages == 1) && (_vid_wait_override.value == 0.0))
if ((lvid->numpages == 1) && (_vid_wait_override->value == 0.0))
{
Cvar_SetValue ("vid_wait", (float)VID_WAIT_NONE);
VID_displayedpage = VID_currentpage = 0;
@ -731,9 +731,9 @@ void VID_ExtraSwapBuffers (viddef_t *lvid, vmode_t *pcurrentmode,
// page flipped
regs.x.ax = 0x4f07;
if (vid_wait.value != VID_WAIT_VSYNC)
if (vid_wait->value != VID_WAIT_VSYNC)
{
if ((vid_wait.value == VID_WAIT_DISPLAY_ENABLE) && de_exists)
if ((vid_wait->value == VID_WAIT_DISPLAY_ENABLE) && de_exists)
VID_ExtraWaitDisplayEnable ();
regs.x.bx = VESA_DONT_WAIT_VSYNC;
@ -775,7 +775,7 @@ void VID_ExtraSwapBuffers (viddef_t *lvid, vmode_t *pcurrentmode,
else
{
// non-page-flipped
if (vsync_exists && (vid_wait.value == VID_WAIT_VSYNC))
if (vsync_exists && (vid_wait->value == VID_WAIT_VSYNC))
{
VGA_WaitVsync ();
}

31
common/vid_ggi.c
View file

@ -44,8 +44,10 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
viddef_t vid; // global video state
unsigned short d_8to16table[256];
cvar_t _windowed_mouse = {"_windowed_mouse","0", CVAR_ARCHIVE};
cvar_t m_filter = {"m_filter","0", CVAR_ARCHIVE};
//cvar_t _windowed_mouse = {"_windowed_mouse","0", CVAR_ARCHIVE};
cvar_t *_windowed_mouse;
//cvar_t m_filter = {"m_filter","0", CVAR_ARCHIVE};
cvar_t *m_filter;
#define NUM_STDBUTTONS 3
#define NUM_BUTTONS 10
@ -887,7 +889,8 @@ void IN_Frame(void)
void
IN_Init(void)
{
Cvar_RegisterVariable(&m_filter);
// Cvar_RegisterVariable(&m_filter);
m_filter = Cvar_Get ("m_filter","0",CVAR_ARCHIVE);
if (COM_CheckParm ("-nomouse")) return;
mouse_x = mouse_y = 0.0;
@ -907,7 +910,7 @@ IN_Move(usercmd_t *cmd)
{
if (!mouse_avail) return;
if (m_filter.value) {
if (m_filter->value) {
mouse_x = (mouse_x + old_mouse_x) * 0.5;
mouse_y = (mouse_y + old_mouse_y) * 0.5;
}
@ -915,27 +918,27 @@ IN_Move(usercmd_t *cmd)
old_mouse_x = mouse_x;
old_mouse_y = mouse_y;
mouse_x *= sensitivity.value;
mouse_y *= sensitivity.value;
mouse_x *= sensitivity->value;
mouse_y *= sensitivity->value;
if ( (in_strafe.state & 1) || (lookstrafe.value && (in_mlook.state & 1) ))
cmd->sidemove += m_side.value * mouse_x;
if ( (in_strafe.state & 1) || (lookstrafe->value && (in_mlook.state & 1) ))
cmd->sidemove += m_side->value * mouse_x;
else
cl.viewangles[YAW] -= m_yaw.value * mouse_x;
cl.viewangles[YAW] -= m_yaw->value * mouse_x;
if (in_mlook.state & 1)
V_StopPitchDrift ();
if ( (in_mlook.state & 1) && !(in_strafe.state & 1)) {
cl.viewangles[PITCH] += m_pitch.value * mouse_y;
cl.viewangles[PITCH] += m_pitch->value * mouse_y;
if (cl.viewangles[PITCH] > 80)
cl.viewangles[PITCH] = 80;
if (cl.viewangles[PITCH] < -70)
cl.viewangles[PITCH] = -70;
} else {
if ((in_strafe.state & 1) && noclip_anglehack)
cmd->upmove -= m_forward.value * mouse_y;
cmd->upmove -= m_forward->value * mouse_y;
else
cmd->forwardmove -= m_forward.value * mouse_y;
cmd->forwardmove -= m_forward->value * mouse_y;
}
mouse_x = mouse_y = 0.0;
}
@ -946,7 +949,7 @@ VID_ExtraOptionDraw(unsigned int options_draw_cursor)
{
// Windowed Mouse
M_Print (16, options_draw_cursor+=8, " Use Mouse");
M_DrawCheckbox (220, options_draw_cursor, _windowed_mouse.value);
M_DrawCheckbox (220, options_draw_cursor, _windowed_mouse->value);
}
@ -955,7 +958,7 @@ VID_ExtraOptionCmd(int option_cursor)
{
switch(option_cursor) {
case 1: // _windowed_mouse
Cvar_SetValue ("_windowed_mouse", !_windowed_mouse.value);
Cvar_SetValue ("_windowed_mouse", !_windowed_mouse->value);
break;
}

45
common/vid_sdl.c
View file

@ -33,9 +33,12 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include <cmd.h>
#include <client.h>
static float old_windowed_mouse = 0;
cvar_t _windowed_mouse = {"_windowed_mouse","0",CVAR_ARCHIVE};
//cvar_t _windowed_mouse = {"_windowed_mouse","0", CVAR_ARCHIVE};
cvar_t *_windowed_mouse;
static float old_windowed_mouse = 0;
viddef_t vid; // global video state
unsigned short d_8to16table[256];
@ -90,7 +93,9 @@ void VID_Init (unsigned char *palette)
//Uint16 video_w, video_h;
Uint32 flags;
S_Init();
S_Init();
// Load the SDL library
if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_CDROM)<0) //|SDL_INIT_AUDIO|SDL_INIT_CDROM) < 0)
Sys_Error("VID: Couldn't load SDL: %s", SDL_GetError());
@ -327,7 +332,7 @@ void Sys_SendKeyEvents(void)
break;
case SDL_MOUSEMOTION:
if (_windowed_mouse.value)
if (_windowed_mouse->value)
{
if ((event.motion.x != (vid.width/2)) ||
(event.motion.y != (vid.height/2)) ) {
@ -351,9 +356,9 @@ void Sys_SendKeyEvents(void)
break;
}
}
if (old_windowed_mouse != _windowed_mouse.value)
{ old_windowed_mouse = _windowed_mouse.value;
if (_windowed_mouse.value && !COM_CheckParm("-nomouse"))
if (old_windowed_mouse != _windowed_mouse->value)
{ old_windowed_mouse = _windowed_mouse->value;
if (_windowed_mouse->value && !COM_CheckParm("-nomouse"))
{ mouse_avail = 1;
}
else
@ -364,11 +369,11 @@ void Sys_SendKeyEvents(void)
void IN_Init (void)
{
fprintf(stderr,"IN_Init started\n");
if ( COM_CheckParm("-nomouse") && !_windowed_mouse.value)
_windowed_mouse = Cvar_Get ("_windowed_mouse","0",CVAR_ARCHIVE,"None");
if ( COM_CheckParm("-nomouse") && !_windowed_mouse->value)
return;
Cvar_RegisterVariable(&_windowed_mouse);
mouse_x = mouse_y = 0.0;
mouse_avail = 1;
}
@ -407,27 +412,27 @@ void IN_Move (usercmd_t *cmd)
if (!mouse_avail)
return;
mouse_x *= sensitivity.value;
mouse_y *= sensitivity.value;
mouse_x *= sensitivity->value;
mouse_y *= sensitivity->value;
if ( (in_strafe.state & 1) || (lookstrafe.value && (in_mlook.state & 1) ))
cmd->sidemove += m_side.value * mouse_x;
if ( (in_strafe.state & 1) || (lookstrafe->value && (in_mlook.state & 1) ))
cmd->sidemove += m_side->value * mouse_x;
else
cl.viewangles[YAW] -= m_yaw.value * mouse_x;
cl.viewangles[YAW] -= m_yaw->value * mouse_x;
if (in_mlook.state & 1)
V_StopPitchDrift ();
if ( (in_mlook.state & 1) && !(in_strafe.state & 1)) {
cl.viewangles[PITCH] += m_pitch.value * mouse_y;
cl.viewangles[PITCH] += m_pitch->value * mouse_y;
if (cl.viewangles[PITCH] > 80)
cl.viewangles[PITCH] = 80;
if (cl.viewangles[PITCH] < -70)
cl.viewangles[PITCH] = -70;
} else {
if ((in_strafe.state & 1) && noclip_anglehack)
cmd->upmove -= m_forward.value * mouse_y;
cmd->upmove -= m_forward->value * mouse_y;
else
cmd->forwardmove -= m_forward.value * mouse_y;
cmd->forwardmove -= m_forward->value * mouse_y;
}
mouse_x = mouse_y = 0.0;
}
@ -448,14 +453,14 @@ void VID_ExtraOptionDraw(unsigned int options_draw_cursor)
{
// Windowed Mouse
M_Print (16, options_draw_cursor+=8, " Use Mouse");
M_DrawCheckbox (220, options_draw_cursor, _windowed_mouse.value);
M_DrawCheckbox (220, options_draw_cursor, _windowed_mouse->value);
}
void VID_ExtraOptionCmd(int option_cursor)
{
switch(option_cursor) {
case 1: // _windowed_mouse
Cvar_SetValue ("_windowed_mouse", !_windowed_mouse.value);
_windowed_mouse->value = !_windowed_mouse->value;
break;
}

80
common/vid_sunx.c
View file

@ -58,6 +58,14 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include <client.h>
#include <input.h>
<<<<<<< vid_sunx.c
//cvar_t _windowed_mouse = {"_windowed_mouse","0", CVAR_ARCHIVE};
cvar_t *_windowed_mouse;
//cvar_t m_filter = {"m_filter","0", CVAR_ARCHIVE};
cvar_t *m_filter;
=======
>>>>>>> 1.27
static qboolean mouse_avail;
static float mouse_x, mouse_y;
static int p_mouse_x, p_mouse_y;
@ -1143,18 +1151,86 @@ Sys_SendKeyEvents(void)
}
}
<<<<<<< vid_sunx.c
void
IN_Init(void)
{
// Cvar_RegisterVariable(&m_filter);
m_filter = Cvar_Get ("m_filter","0",CVAR_ARCHIVE);
if (COM_CheckParm("-nomouse")) return;
mouse_x = mouse_y = 0.0;
mouse_avail = 1;
}
void
IN_Shutdown(void)
{
mouse_avail = 0;
}
void
IN_Frame(void)
{
/* Nothing to do here */
}
void
IN_Move(usercmd_t *cmd)
{
if (!mouse_avail)
return;
if (m_filter->value) {
mouse_x = (mouse_x + old_mouse_x) * 0.5;
mouse_y = (mouse_y + old_mouse_y) * 0.5;
}
old_mouse_x = mouse_x;
old_mouse_y = mouse_y;
mouse_x *= sensitivity->value;
mouse_y *= sensitivity->value;
if ( (in_strafe.state & 1) || (lookstrafe->value && (in_mlook.state & 1) ))
cmd->sidemove += m_side->value * mouse_x;
else
cl.viewangles[YAW] -= m_yaw->value * mouse_x;
if (in_mlook.state & 1)
V_StopPitchDrift ();
if ( (in_mlook.state & 1) && !(in_strafe.state & 1)) {
cl.viewangles[PITCH] += m_pitch->value * mouse_y;
if (cl.viewangles[PITCH] > 80)
cl.viewangles[PITCH] = 80;
if (cl.viewangles[PITCH] < -70)
cl.viewangles[PITCH] = -70;
} else {
if ((in_strafe.state & 1) && noclip_anglehack)
cmd->upmove -= m_forward->value * mouse_y;
else
cmd->forwardmove -= m_forward->value * mouse_y;
}
mouse_x = mouse_y = 0.0;
}
=======
>>>>>>> 1.27
void VID_ExtraOptionDraw(unsigned int options_draw_cursor)
{
// Windowed Mouse
M_Print(16, options_draw_cursor+=8, " Use Mouse");
M_DrawCheckbox(220, options_draw_cursor, _windowed_mouse.value);
M_DrawCheckbox(220, options_draw_cursor, _windowed_mouse->value);
}
void VID_ExtraOptionCmd(int option_cursor)
{
switch (option_cursor) {
case 1: // _windowed_mouse
Cvar_SetValue ("_windowed_mouse", !_windowed_mouse.value);
Cvar_SetValue ("_windowed_mouse", !_windowed_mouse->value);
break;
}
}

56
common/vid_sunxil.c
View file

@ -50,8 +50,10 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#define MIN_WIDTH 320
#define MIN_HEIGHT 200
cvar_t _windowed_mouse = {"_windowed_mouse","0", true};
cvar_t m_filter = {"m_filter","0", true};
//cvar_t _windowed_mouse = {"_windowed_mouse","0", true};
cvar_t *_windowed_mouse;
//cvar_t m_filter = {"m_filter","0", true};
cvar_t *m_filter;
float old_windowed_mouse;
// The following X property format is defined in Motif 1.1's
@ -151,7 +153,8 @@ static int verbose=1;
static byte current_palette[768];
cvar_t pixel_multiply = {"pixel_multiply", "2", true};
//cvar_t pixel_multiply = {"pixel_multiply", "2", true};
cvar_t *pixel_multiply;
int current_pixel_multiply = 2;
#define PM(a) (int)((current_pixel_multiply)?((a)*current_pixel_multiply):(a))
@ -231,7 +234,7 @@ qboolean CheckPixelMultiply (void)
unsigned int value_mask;
int old_pixel;
if ((m = (int)pixel_multiply.value) != current_pixel_multiply) {
if ((m = (int)pixel_multiply->value) != current_pixel_multiply) {
if (m < 1)
m = 1;
if (m > 4)
@ -323,7 +326,7 @@ void VID_SetWindowTitle( Window win, char *pszName )
XWMHints *wmHints;
// Setup ICCCM properties
textprop.value = (unsigned char *)pszName;
textprop->value = (unsigned char *)pszName;
textprop.encoding = XA_STRING;
textprop.format = 8;
textprop.nitems = strlen(pszName);
@ -380,7 +383,8 @@ void VID_Init (unsigned char *palette)
Cmd_AddCommand ("gamma", VID_Gamma_f);
Cvar_RegisterVariable (&pixel_multiply);
// Cvar_RegisterVariable (&pixel_multiply);
pixel_multiply = Cvar_Get ("pixel_multiply","2",CVAR_ARCHIVE);
if (pipe(render_pipeline) < 0)
Sys_Error("VID_Init: pipe");
@ -495,9 +499,9 @@ void VID_Init (unsigned char *palette)
//
// See if we're going to do pixel multiply
//
if (pixel_multiply.value < 1 || pixel_multiply.value > 4)
if (pixel_multiply->value < 1 || pixel_multiply->value > 4)
Cvar_SetValue("pixel_multiply", 2);
current_pixel_multiply = pixel_multiply.value;
current_pixel_multiply = pixel_multiply->value;
w = 320*current_pixel_multiply; // minimum width
h = 200*current_pixel_multiply; // minimum height
@ -824,7 +828,7 @@ void GetEvent(void)
case MotionNotify:
if (_windowed_mouse.value) {
if (_windowed_mouse->value) {
mouse_x = (float) ((int)x_event.xmotion.x - (int)(vid.width/2));
mouse_y = (float) ((int)x_event.xmotion.y - (int)(vid.height/2));
//printf("m: x=%d,y=%d, mx=%3.2f,my=%3.2f\n",
@ -892,10 +896,10 @@ void GetEvent(void)
#endif
}
if (old_windowed_mouse != _windowed_mouse.value) {
old_windowed_mouse = _windowed_mouse.value;
if (old_windowed_mouse != _windowed_mouse->value) {
old_windowed_mouse = _windowed_mouse->value;
if (!_windowed_mouse.value) {
if (!_windowed_mouse->value) {
/* ungrab the pointer */
XUngrabPointer(x_disp,CurrentTime);
} else {
@ -1182,8 +1186,10 @@ void Sys_SendKeyEvents(void)
void IN_Init (void)
{
Cvar_RegisterVariable (&_windowed_mouse);
Cvar_RegisterVariable (&m_filter);
// Cvar_RegisterVariable (&_windowed_mouse);
_windowed_mouse = Cvar_Get ("_windowed_mouse","0",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&m_filter);
m_filter = Cvar_Get ("m_filter","0",CVAR_ARCHIVE);
if ( COM_CheckParm ("-nomouse") )
return;
mouse_x = mouse_y = 0.0;
@ -1220,7 +1226,7 @@ void IN_Move (usercmd_t *cmd)
if (!mouse_avail)
return;
if (m_filter.value) {
if (m_filter->value) {
mouse_x = (mouse_x + old_mouse_x) * 0.5;
mouse_y = (mouse_y + old_mouse_y) * 0.5;
}
@ -1228,27 +1234,27 @@ void IN_Move (usercmd_t *cmd)
old_mouse_x = mouse_x;
old_mouse_y = mouse_y;
mouse_x *= sensitivity.value;
mouse_y *= sensitivity.value;
mouse_x *= sensitivity->value;
mouse_y *= sensitivity->value;
if ( (in_strafe.state & 1) || (lookstrafe.value && (in_mlook.state & 1) ))
cmd->sidemove += m_side.value * mouse_x;
if ( (in_strafe.state & 1) || (lookstrafe->value && (in_mlook.state & 1) ))
cmd->sidemove += m_side->value * mouse_x;
else
cl.viewangles[YAW] -= m_yaw.value * mouse_x;
cl.viewangles[YAW] -= m_yaw->value * mouse_x;
if (in_mlook.state & 1)
V_StopPitchDrift ();
if ( (in_mlook.state & 1) && !(in_strafe.state & 1)) {
cl.viewangles[PITCH] += m_pitch.value * mouse_y;
cl.viewangles[PITCH] += m_pitch->value * mouse_y;
if (cl.viewangles[PITCH] > 80)
cl.viewangles[PITCH] = 80;
if (cl.viewangles[PITCH] < -70)
cl.viewangles[PITCH] = -70;
} else {
if ((in_strafe.state & 1) && noclip_anglehack)
cmd->upmove -= m_forward.value * mouse_y;
cmd->upmove -= m_forward->value * mouse_y;
else
cmd->forwardmove -= m_forward.value * mouse_y;
cmd->forwardmove -= m_forward->value * mouse_y;
}
mouse_x = mouse_y = 0.0;
}
@ -1257,14 +1263,14 @@ void VID_ExtraOptionDraw(unsigned int options_draw_cursor)
{
// Windowed Mouse
M_Print (16, options_draw_cursor+=8, " Use Mouse");
M_DrawCheckbox (220, options_draw_cursor, _windowed_mouse.value);
M_DrawCheckbox (220, options_draw_cursor, _windowed_mouse->value);
}
void VID_ExtraOptionCmd(int option_cursor)
{
switch(option_cursor) {
case 1: // _windowed_mouse
Cvar_SetValue ("_windowed_mouse", !_windowed_mouse.value);
Cvar_SetValue ("_windowed_mouse", !_windowed_mouse->value);
break;
}

31
common/vid_svgalib.c
View file

@ -62,9 +62,12 @@ static byte vid_current_palette[768];
static int svgalib_inited=0;
static int UseDisplay = 1;
static cvar_t vid_mode = {"vid_mode","5",false};
static cvar_t vid_redrawfull = {"vid_redrawfull","0",false};
static cvar_t vid_waitforrefresh = {"vid_waitforrefresh","0",true};
//static cvar_t vid_mode = {"vid_mode","5",false};
static cvar_t *vid_mode;
// static cvar_t vid_redrawfull = {"vid_redrawfull","0",false};
static cvar_t *vid_redrawfull;
//static cvar_t vid_waitforrefresh = {"vid_waitforrefresh","0",true};
static cvar_t *vid_waitforrefresh;
static char *framebuffer_ptr;
@ -400,14 +403,14 @@ VID_SetMode(int modenum, unsigned char *palette)
int err;
if ((modenum >= num_modes) || (modenum < 0) || !modes[modenum].width){
Cvar_SetValue ("vid_mode", (float)current_mode);
vid_mode->value = (float)current_mode;
Con_Printf("No such video mode: %d\n",modenum);
return 0;
}
Cvar_SetValue ("vid_mode", (float)modenum);
vid_mode->value = (float)modenum;
current_mode=modenum;
@ -510,9 +513,13 @@ VID_Init(unsigned char *palette)
VID_InitModes();
Cvar_RegisterVariable (&vid_mode);
Cvar_RegisterVariable (&vid_redrawfull);
Cvar_RegisterVariable (&vid_waitforrefresh);
// Cvar_RegisterVariable (&vid_mode);
vid_mode = Cvar_Get ("vid_mode","5",0,"None");
// Cvar_RegisterVariable (&vid_redrawfull);
vid_redrawfull = Cvar_Get ("vid_redrawfull","0",0,"None");
// Cvar_RegisterVariable (&vid_waitforrefresh);
vid_waitforrefresh = Cvar_Get ("vid_waitforrefresh","0",
CVAR_ARCHIVE,"None");
Cmd_AddCommand("vid_nummodes", VID_NumModes_f);
Cmd_AddCommand("vid_describemode", VID_DescribeMode_f);
@ -564,13 +571,13 @@ VID_Update(vrect_t *rects)
return;
}
if (vid_waitforrefresh.value) {
if (vid_waitforrefresh->value) {
vga_waitretrace();
}
if (VGA_planar) {
VGA_UpdatePlanarScreen(vid.buffer);
} else if (vid_redrawfull.value) {
} else if (vid_redrawfull->value) {
int total = vid.rowbytes * vid.height;
int offset;
@ -616,8 +623,8 @@ VID_Update(vrect_t *rects)
}
}
if (vid_mode.value != current_mode) {
VID_SetMode ((int)vid_mode.value, vid_current_palette);
if (vid_mode->value != current_mode) {
VID_SetMode ((int)vid_mode->value, vid_current_palette);
}
}

4
common/vid_vga.c
View file

@ -390,7 +390,7 @@ int VGA_InitMode (viddef_t *lvid, vmode_t *pcurrentmode)
VGA_ClearVideoMem (pcurrentmode->planar);
if (_vid_wait_override.value)
if (_vid_wait_override->value)
{
Cvar_SetValue ("vid_wait", (float)VID_WAIT_VSYNC);
}
@ -472,7 +472,7 @@ void VGA_SwapBuffers (viddef_t *lvid, vmode_t *pcurrentmode, vrect_t *rects)
{
UNUSED(lvid);
if (vid_wait.value == VID_WAIT_VSYNC)
if (vid_wait->value == VID_WAIT_VSYNC)
VGA_WaitVsync ();
VGA_SwapBuffersCopy (lvid, pcurrentmode, rects);

165
common/vid_win.c
View file

@ -90,23 +90,38 @@ viddef_t vid; // global video state
#define MODE_FULLSCREEN_DEFAULT (MODE_WINDOWED + 3)
// Note that 0 is MODE_WINDOWED
cvar_t vid_mode = {"vid_mode","0", CVAR_NONE};
//cvar_t vid_mode = {"vid_mode","0", CVAR_NONE};
cvar_t *vid_mode;
// Note that 0 is MODE_WINDOWED
cvar_t _vid_default_mode = {"_vid_default_mode","0", CVAR_ARCHIVE};
//cvar_t _vid_default_mode = {"_vid_default_mode","0", CVAR_ARCHIVE};
cvar_t *_vid_default_mode;
// Note that 3 is MODE_FULLSCREEN_DEFAULT
cvar_t _vid_default_mode_win = {"_vid_default_mode_win","3", CVAR_ARCHIVE};
cvar_t vid_wait = {"vid_wait","0"};
cvar_t vid_nopageflip = {"vid_nopageflip","0", CVAR_ARCHIVE};
cvar_t _vid_wait_override = {"_vid_wait_override", "0", CVAR_ARCHIVE};
cvar_t vid_config_x = {"vid_config_x","800", CVAR_ARCHIVE};
cvar_t vid_config_y = {"vid_config_y","600", CVAR_ARCHIVE};
cvar_t vid_stretch_by_2 = {"vid_stretch_by_2","1", CVAR_ARCHIVE};
cvar_t _windowed_mouse = {"_windowed_mouse","0", CVAR_ARCHIVE};
cvar_t vid_fullscreen_mode = {"vid_fullscreen_mode","3", CVAR_ARCHIVE};
cvar_t vid_windowed_mode = {"vid_windowed_mode","0", CVAR_ARCHIVE};
cvar_t block_switch = {"block_switch","0", CVAR_ARCHIVE};
cvar_t vid_window_x = {"vid_window_x", "0", CVAR_ARCHIVE};
cvar_t vid_window_y = {"vid_window_y", "0", CVAR_ARCHIVE};
//cvar_t _vid_default_mode_win = {"_vid_default_mode_win","3", CVAR_ARCHIVE};
cvar_t *_vid_default_mode_win;
//cvar_t vid_wait = {"vid_wait","0"};
cvar_t *vid_wait;
//cvar_t vid_nopageflip = {"vid_nopageflip","0", CVAR_ARCHIVE};
cvar_t *vid_nopageflip;
//cvar_t _vid_wait_override = {"_vid_wait_override", "0", CVAR_ARCHIVE};
cvar_t *_vid_wait_override;
//cvar_t vid_config_x = {"vid_config_x","800", CVAR_ARCHIVE};
cvar_t *vid_config_x;
//cvar_t vid_config_y = {"vid_config_y","600", CVAR_ARCHIVE};
cvar_t *vid_config_y;
//cvar_t vid_stretch_by_2 = {"vid_stretch_by_2","1", CVAR_ARCHIVE};
cvar_t *vid_stretch_by_2;
//cvar_t _windowed_mouse = {"_windowed_mouse","0", CVAR_ARCHIVE};
cvar_t *_windowed_mouse;
//cvar_t vid_fullscreen_mode = {"vid_fullscreen_mode","3", CVAR_ARCHIVE};
cvar_t *vid_fullscreen_mode;
//cvar_t vid_windowed_mode = {"vid_windowed_mode","0", CVAR_ARCHIVE};
cvar_t *vid_windowed_mode;
//cvar_t block_switch = {"block_switch","0", CVAR_ARCHIVE};
cvar_t *block_switch;
//cvar_t vid_window_x = {"vid_window_x", "0", CVAR_ARCHIVE};
cvar_t *vid_window_x;
//cvar_t vid_window_y = {"vid_window_y", "0", CVAR_ARCHIVE};
cvar_t *vid_window_y;
typedef struct {
int width;
@ -206,10 +221,10 @@ VID_CheckWindowXY
void VID_CheckWindowXY (void)
{
if (((int)vid_window_x.value > (GetSystemMetrics (SM_CXSCREEN) - 160)) ||
((int)vid_window_y.value > (GetSystemMetrics (SM_CYSCREEN) - 120)) ||
((int)vid_window_x.value < 0) ||
((int)vid_window_y.value < 0))
if (((int)vid_window_x->value > (GetSystemMetrics (SM_CXSCREEN) - 160)) ||
((int)vid_window_y->value > (GetSystemMetrics (SM_CYSCREEN) - 120)) ||
((int)vid_window_x->value < 0) ||
((int)vid_window_y->value < 0))
{
Cvar_SetValue ("vid_window_x", 0.0);
Cvar_SetValue ("vid_window_y", 0.0 );
@ -375,7 +390,7 @@ int VID_Suspend (MGLDC *dc, int flags)
if (flags & MGL_DEACTIVATE)
{
// FIXME: this doesn't currently work on NT
if (block_switch.value && !WinNT)
if (block_switch->value && !WinNT)
{
return MGL_NO_DEACTIVATE;
}
@ -1098,17 +1113,17 @@ void VID_CheckModedescFixup (int mode)
if (mode == MODE_SETTABLE_WINDOW)
{
modelist[mode].stretched = (int)vid_stretch_by_2.value;
modelist[mode].stretched = (int)vid_stretch_by_2->value;
stretch = modelist[mode].stretched;
if (vid_config_x.value < (320 << stretch))
vid_config_x.value = 320 << stretch;
if (vid_config_x->value < (320 << stretch))
vid_config_x->value = 320 << stretch;
if (vid_config_y.value < (200 << stretch))
vid_config_y.value = 200 << stretch;
if (vid_config_y->value < (200 << stretch))
vid_config_y->value = 200 << stretch;
x = (int)vid_config_x.value;
y = (int)vid_config_y.value;
x = (int)vid_config_x->value;
y = (int)vid_config_y->value;
snprintf(modelist[mode].modedesc, sizeof(modelist[mode].modedesc), "%dx%d", x, y);
modelist[mode].width = x;
modelist[mode].height = y;
@ -1383,8 +1398,8 @@ qboolean VID_SetWindowedMode (int modenum)
// position and show the DIB window
VID_CheckWindowXY ();
SetWindowPos (mainwindow, NULL, (int)vid_window_x.value,
(int)vid_window_y.value, 0, 0,
SetWindowPos (mainwindow, NULL, (int)vid_window_x->value,
(int)vid_window_y->value, 0, 0,
SWP_NOSIZE | SWP_NOZORDER | SWP_SHOWWINDOW | SWP_DRAWFRAME);
if (force_minimized)
@ -1451,7 +1466,7 @@ qboolean VID_SetFullscreenMode (int modenum)
mgldc = memdc = NULL;
if ((mgldc = createDisplayDC (modelist[modenum].stretched ||
(int)vid_nopageflip.value)) == NULL)
(int)vid_nopageflip->value)) == NULL)
{
return false;
}
@ -1675,7 +1690,7 @@ int VID_SetMode (int modenum, unsigned char *palette)
// Set either the fullscreen or windowed mode
if (modelist[modenum].type == MS_WINDOWED)
{
if (_windowed_mouse.value && key_dest == key_game)
if (_windowed_mouse->value && key_dest == key_game)
{
stat = VID_SetWindowedMode(modenum);
IN_ActivateMouse ();
@ -1816,7 +1831,7 @@ void VID_LockBuffer (void)
else
screenwidth = vid.rowbytes;
if (lcd_x.value)
if (lcd_x->value)
screenwidth <<= 1;
}
@ -2068,7 +2083,7 @@ VID_Windowed_f
void VID_Windowed_f (void)
{
VID_SetMode ((int)vid_windowed_mode.value, vid_curpal);
VID_SetMode ((int)vid_windowed_mode->value, vid_curpal);
}
@ -2080,7 +2095,7 @@ VID_Fullscreen_f
void VID_Fullscreen_f (void)
{
VID_SetMode ((int)vid_fullscreen_mode.value, vid_curpal);
VID_SetMode ((int)vid_fullscreen_mode->value, vid_curpal);
}
@ -2125,6 +2140,17 @@ void VID_Init (unsigned char *palette)
int i, bestmatchmetric, t, dr, dg, db, bestmatch = 0;
int basenummodes;
byte *ptmp;
<<<<<<< vid_win.c
// Cvar_RegisterVariable (&vid_mode);
vid_mode = Cvar_Get ("vid_mode","0");
// Cvar_RegisterVariable (&vid_wait);
vid_wait = Cvar_Get ("vid_wait","0");
// Cvar_RegisterVariable (&vid_nopageflip);
vid_nopageflip = Cvar_Get ("vid_nopageflip","0",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&_vid_wait_override);
_vid_wait_override = Cvar_Get ("_vid_wait_override","0",CVAR_ARCHIVE);
=======
plugin_load("input");
@ -2134,17 +2160,30 @@ void VID_Init (unsigned char *palette)
Cvar_RegisterVariable (&vid_wait);
Cvar_RegisterVariable (&vid_nopageflip);
Cvar_RegisterVariable (&_vid_wait_override);
>>>>>>> 1.17
Cvar_RegisterVariable (&_vid_default_mode);
Cvar_RegisterVariable (&_vid_default_mode_win);
Cvar_RegisterVariable (&vid_config_x);
Cvar_RegisterVariable (&vid_config_y);
Cvar_RegisterVariable (&vid_stretch_by_2);
Cvar_RegisterVariable (&_windowed_mouse);
Cvar_RegisterVariable (&vid_fullscreen_mode);
Cvar_RegisterVariable (&vid_windowed_mode);
Cvar_RegisterVariable (&block_switch);
Cvar_RegisterVariable (&vid_window_x);
Cvar_RegisterVariable (&vid_window_y);
_vid_default_mode = Cvar_Get ("_vid_default_mode","0",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&_vid_default_mode_win);
_vid_default_mode_win = Cvar_Get ("_vid_default_mode_win","3",
CVAR_ARCHIVE);
// Cvar_RegisterVariable (&vid_config_x);
vid_config_x = Cvar_Get ("vid_config_x","800",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&vid_config_y);
vid_config_y = Cvar_Get ("vid_config_y","600",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&vid_stretch_by_2);
vid_stretch_by_2 = Cvar_Get ("vid_stretch_by_2","1",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&_windowed_mouse);
_windowed_mouse = Cvar_Get ("_windowed_mouse","0",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&vid_fullscreen_mode);
vid_fullscreen_mode = Cvar_Get ("vid_fullscreen_mode","3",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&vid_windowed_mode);
vid_windowed_mode = Cvar_Get ("vid_windowed_mode","0",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&block_switch);
block_switch = Cvar_Get ("block_switch","0",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&vid_window_x);
vid_window_x = Cvar_Get ("vid_window_x","0",CVAR_ARCHIVE);
// Cvar_RegisterVariable (&vid_window_y);
vid_window_y = Cvar_Get ("vid_window_y","0",CVAR_ARCHIVE);
Cmd_AddCommand ("vid_testmode", VID_TestMode_f);
Cmd_AddCommand ("vid_nummodes", VID_NumModes_f);
@ -2388,8 +2427,8 @@ void VID_Update (vrect_t *rects)
{
GetWindowRect (mainwindow, &trect);
if ((trect.left != (int)vid_window_x.value) ||
(trect.top != (int)vid_window_y.value))
if ((trect.left != (int)vid_window_x->value) ||
(trect.top != (int)vid_window_y->value))
{
if (COM_CheckParm ("-resetwinpos"))
{
@ -2398,14 +2437,14 @@ void VID_Update (vrect_t *rects)
}
VID_CheckWindowXY ();
SetWindowPos (mainwindow, NULL, (int)vid_window_x.value,
(int)vid_window_y.value, 0, 0,
SetWindowPos (mainwindow, NULL, (int)vid_window_x->value,
(int)vid_window_y->value, 0, 0,
SWP_NOSIZE | SWP_NOZORDER | SWP_SHOWWINDOW | SWP_DRAWFRAME);
}
}
if ((_vid_default_mode_win.value != vid_default) &&
(!startwindowed || (_vid_default_mode_win.value < MODE_FULLSCREEN_DEFAULT)))
if ((_vid_default_mode_win->value != vid_default) &&
(!startwindowed || (_vid_default_mode_win->value < MODE_FULLSCREEN_DEFAULT)))
{
firstupdate = 0;
@ -2415,13 +2454,13 @@ void VID_Update (vrect_t *rects)
Cvar_SetValue ("vid_window_y", 0.0);
}
if ((_vid_default_mode_win.value < 0) ||
(_vid_default_mode_win.value >= nummodes))
if ((_vid_default_mode_win->value < 0) ||
(_vid_default_mode_win->value >= nummodes))
{
Cvar_SetValue ("_vid_default_mode_win", windowed_default);
}
Cvar_SetValue ("vid_mode", _vid_default_mode_win.value);
Cvar_SetValue ("vid_mode", _vid_default_mode_win->value);
}
}
@ -2438,9 +2477,9 @@ void VID_Update (vrect_t *rects)
}
else
{
if ((int)vid_mode.value != vid_realmode)
if ((int)vid_mode->value != vid_realmode)
{
VID_SetMode ((int)vid_mode.value, vid_curpal);
VID_SetMode ((int)vid_mode->value, vid_curpal);
Cvar_SetValue ("vid_mode", (float)vid_modenum);
// so if mode set fails, we don't keep on
// trying to set that mode
@ -2451,7 +2490,7 @@ void VID_Update (vrect_t *rects)
// handle the mouse state when windowed if that's changed
if (modestate == MS_WINDOWED)
{
if (!_windowed_mouse.value) {
if (!_windowed_mouse->value) {
if (windowed_mouse) {
IN_DeactivateMouse ();
IN_ShowMouse ();
@ -2800,7 +2839,7 @@ void AppActivate(BOOL fActive, BOOL minimize)
IN_ActivateMouse ();
IN_HideMouse ();
}
else if ((modestate == MS_WINDOWED) && _windowed_mouse.value && key_dest == key_game)
else if ((modestate == MS_WINDOWED) && _windowed_mouse->value && key_dest == key_game)
{
IN_ActivateMouse ();
IN_HideMouse ();
@ -2832,7 +2871,7 @@ void AppActivate(BOOL fActive, BOOL minimize)
IN_DeactivateMouse ();
IN_ShowMouse ();
}
else if ((modestate == MS_WINDOWED) && _windowed_mouse.value)
else if ((modestate == MS_WINDOWED) && _windowed_mouse->value)
{
IN_DeactivateMouse ();
IN_ShowMouse ();
@ -2850,7 +2889,7 @@ VID_HandlePause
void VID_HandlePause (qboolean pause)
{ // Why?
#if 0
if ((modestate == MS_WINDOWED) && _windowed_mouse.value)
if ((modestate == MS_WINDOWED) && _windowed_mouse->value)
{
if (pause)
{
@ -2915,7 +2954,7 @@ LONG WINAPI MainWndProc (
force_mode_set = false;
}
VID_SetMode ((int)vid_fullscreen_mode.value, vid_curpal);
VID_SetMode ((int)vid_fullscreen_mode->value, vid_curpal);
break;
case SC_SCREENSAVE:
@ -3297,7 +3336,7 @@ void VID_MenuDraw (void)
M_Print (2*8, 36 + MODE_AREA_HEIGHT * 8 + 8*5, temp);
}
ptr = VID_GetModeDescription2 ((int)_vid_default_mode_win.value);
ptr = VID_GetModeDescription2 ((int)_vid_default_mode_win->value);
if (ptr)
{
@ -3419,7 +3458,7 @@ void VID_ExtraOptionDraw(unsigned int options_draw_cursor)
if (modestate == MS_WINDOWED) {
// Windowed Mouse
M_Print (16, options_draw_cursor+=8, " Use Mouse");
M_DrawCheckbox (220, options_draw_cursor, _windowed_mouse.value);
M_DrawCheckbox (220, options_draw_cursor, _windowed_mouse->value);
}
}
@ -3427,7 +3466,7 @@ void VID_ExtraOptionCmd(int option_cursor)
{
switch(option_cursor) {
case 1: // _windowed_mouse
Cvar_SetValue ("_windowed_mouse", !_windowed_mouse.value);
Cvar_SetValue ("_windowed_mouse", !_windowed_mouse->value);
break;
}

4
common/view.h
View file

@ -21,12 +21,12 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
// view.h
extern cvar_t v_gamma;
extern cvar_t *v_gamma;
extern byte gammatable[256]; // palette is sent through this
extern byte ramps[3][256];
extern float v_blend[4];
extern cvar_t lcd_x;
extern cvar_t *lcd_x;
void V_Init (void);
void V_RenderView (void);

6
configure.in
View file

@ -477,7 +477,7 @@ dnl CFLAGS for release and devel versions
if test "x$RELEASE" = xyes; then
if test "x$GCC" = xyes; then
AC_MSG_CHECKING(for special release compiler settings)
BASE_RELEASE_CFLAGS="-Wall -Werror -O6 -ffast-math -funroll-loops -fomit-frame-pointer -fexpensive-optimizations"
BASE_RELEASE_CFLAGS="-lefence -Wall -Werror -O6 -ffast-math -funroll-loops -fomit-frame-pointer -fexpensive-optimizations"
case "${target}" in
changequote(,)dnl
i?86-*-*)
@ -508,7 +508,7 @@ if test "x$GCC" != xyes; then
AC_MSG_CHECKING(for how to deal with C++ comments)
case "$target" in
*-aix*)
CFLAGS="$CFLAGS -qcpluscmt"
CFLAGS="-lefence $CFLAGS -qcpluscmt"
AC_MSG_RESULT([-qcpluscmt])
;;
*-irix6*)
@ -527,7 +527,7 @@ fi
dnl We want warnings, lots of warnings...
if test "x$GCC" = xyes; then
CFLAGS="$CFLAGS -Wall -Werror"
CFLAGS="-lefence $CFLAGS -Wall -Werror"
fi
# CFLAGS="$CFLAGS -Wall -pedantic"

8
qw_client/cl_parse.c
View file

@ -1015,7 +1015,7 @@ void CL_MuzzleFlash (void)
return;
// don't draw our own muzzle flash in gl if flashblending
if (i-1 == cl.playernum && gl_flashblend.value)
if (i-1 == cl.playernum && gl_flashblend->value)
return;
pl = &cl.frames[parsecountmod].playerstate[i-1];
@ -1035,7 +1035,7 @@ void CL_MuzzleFlash (void)
}
#define SHOWNET(x) if(cl_shownet.value==2)Con_Printf ("%3i:%s\n", msg_readcount-1, x);
#define SHOWNET(x) if(cl_shownet->value==2)Con_Printf ("%3i:%s\n", msg_readcount-1, x);
/*
=====================
CL_ParseServerMessage
@ -1054,9 +1054,9 @@ void CL_ParseServerMessage (void)
//
// if recording demos, copy the message out
//
if (cl_shownet.value == 1)
if (cl_shownet->value == 1)
Con_Printf ("%i ",net_message.cursize);
else if (cl_shownet.value == 2)
else if (cl_shownet->value == 2)
Con_Printf ("------------------\n");

18
qw_client/cl_pred.c
View file

@ -28,8 +28,10 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "console.h"
#include "mathlib.h"
cvar_t cl_nopred = {"cl_nopred","0"};
cvar_t cl_pushlatency = {"pushlatency","-999"};
//cvar_t cl_nopred = {"cl_nopred","0"};
cvar_t *cl_nopred;
//cvar_t cl_pushlatency = {"pushlatency","-999"};
cvar_t *cl_pushlatency;
extern frame_t *view_frame;
@ -124,13 +126,13 @@ void CL_PredictMove (void)
frame_t *from, *to = NULL;
int oldphysent;
if (cl_pushlatency.value > 0)
if (cl_pushlatency->value > 0)
Cvar_Set ("pushlatency", "0");
if (cl.paused)
return;
cl.time = realtime - cls.latency - cl_pushlatency.value*0.001;
cl.time = realtime - cls.latency - cl_pushlatency->value*0.001;
if (cl.time > realtime)
cl.time = realtime;
@ -160,7 +162,7 @@ void CL_PredictMove (void)
#endif
}
if (cl_nopred.value)
if (cl_nopred->value)
{
VectorCopy (from->playerstate[cl.playernum].velocity, cl.simvel);
VectorCopy (from->playerstate[cl.playernum].origin, cl.simorg);
@ -227,7 +229,9 @@ CL_InitPrediction
*/
void CL_InitPrediction (void)
{
Cvar_RegisterVariable (&cl_pushlatency);
Cvar_RegisterVariable (&cl_nopred);
// Cvar_RegisterVariable (&cl_pushlatency);
cl_pushlatency = Cvar_Get ("cl_pushlatency","0",0,"None");
// Cvar_RegisterVariable (&cl_nopred);
cl_nopred = Cvar_Get ("cl_nopred","0",0,"None");
}

4
qw_client/d_edge.c
View file

@ -187,7 +187,7 @@ void D_DrawSurfaces (void)
VectorCopy (transformed_modelorg, world_transformed_modelorg);
// TODO: could preset a lot of this at mode set time
if (r_drawflat.value)
if (r_drawflat->value)
{
for (s = &surfaces[1] ; s<surface_p ; s++)
{
@ -233,7 +233,7 @@ void D_DrawSurfaces (void)
d_zistepv = 0;
d_ziorigin = -0.9;
D_DrawSolidSurface (s, (int)r_clearcolor.value & 0xFF);
D_DrawSolidSurface (s, (int)r_clearcolor->value & 0xFF);
D_DrawZSpans (s->spans);
}
else if (s->flags & SURF_DRAWTURB)

103
qw_client/menu.c
View file

@ -401,81 +401,80 @@ void M_AdjustSliders (int dir)
switch (options_cursor)
{
case 3: // screen size
scr_viewsize.value += dir * 10;
if (scr_viewsize.value < 30)
scr_viewsize.value = 30;
if (scr_viewsize.value > 120)
scr_viewsize.value = 120;
Cvar_SetValue ("viewsize", scr_viewsize.value);
scr_viewsize->value += dir * 10;
if (scr_viewsize->value < 30)
scr_viewsize->value = 30;
if (scr_viewsize->value > 120)
scr_viewsize->value = 120;
break;
case 4: // gamma
v_gamma.value -= dir * 0.05;
if (v_gamma.value < 0.5)
v_gamma.value = 0.5;
if (v_gamma.value > 1)
v_gamma.value = 1;
Cvar_SetValue ("gamma", v_gamma.value);
v_gamma->value -= dir * 0.05;
if (v_gamma->value < 0.5)
v_gamma->value = 0.5;
if (v_gamma->value > 1)
v_gamma->value = 1;
break;
case 5: // mouse speed
sensitivity.value += dir * 0.5;
if (sensitivity.value < 1)
sensitivity.value = 1;
if (sensitivity.value > 11)
sensitivity.value = 11;
Cvar_SetValue ("sensitivity", sensitivity.value);
sensitivity->value += dir * 0.5;
if (sensitivity->value < 1)
sensitivity->value = 1;
if (sensitivity->value > 11)
sensitivity->value = 11;
break;
case 6: // music volume
#ifdef _WIN32
bgmvolume.value += dir * 1.0;
bgmvolume->value += dir * 1.0;
#else
bgmvolume.value += dir * 0.1;
bgmvolume->value += dir * 0.1;
#endif
if (bgmvolume.value < 0)
bgmvolume.value = 0;
if (bgmvolume.value > 1)
bgmvolume.value = 1;
Cvar_SetValue ("bgmvolume", bgmvolume.value);
if (bgmvolume->value < 0)
bgmvolume->value = 0;
if (bgmvolume->value > 1)
bgmvolume->value = 1;
break;
case 7: // sfx volume
volume.value += dir * 0.1;
if (volume.value < 0)
volume.value = 0;
if (volume.value > 1)
volume.value = 1;
Cvar_SetValue ("volume", volume.value);
volume->value += dir * 0.1;
if (volume->value < 0)
volume->value = 0;
if (volume->value > 1)
volume->value = 1;
break;
case 8: // allways run
if (cl_forwardspeed.value > 200)
if (cl_forwardspeed->value > 200)
{
Cvar_SetValue ("cl_forwardspeed", 200);
Cvar_SetValue ("cl_backspeed", 200);
cl_forwardspeed->value = 200;
cl_backspeed->value = 200;
}
else
{
Cvar_SetValue ("cl_forwardspeed", 400);
Cvar_SetValue ("cl_backspeed", 400);
cl_forwardspeed->value = 400;
cl_backspeed->value = 400;
}
break;
case 9: // invert mouse
Cvar_SetValue ("m_pitch", -m_pitch.value);
m_pitch->value = -m_pitch->value;
break;
case 10: // lookspring
Cvar_SetValue ("lookspring", !lookspring.value);
lookspring->value = !lookspring->value;
break;
case 11: // lookstrafe
Cvar_SetValue ("lookstrafe", !lookstrafe.value);
lookstrafe->value = !lookstrafe->value;
break;
case 12:
Cvar_SetValue ("cl_sbar", !cl_sbar.value);
cl_sbar->value = !cl_sbar->value;
break;
case 13:
Cvar_SetValue ("cl_hudswap", !cl_hudswap.value);
cl_hudswap->value = !cl_hudswap->value;
/*
default:
@ -530,43 +529,43 @@ void M_Options_Draw (void)
M_Print (16, options_draw_cursor+=8, " Reset to defaults");
M_Print (16, options_draw_cursor+=8, " Screen size");
r = (scr_viewsize.value - 30) / (120 - 30);
r = (scr_viewsize->value - 30) / (120 - 30);
M_DrawSlider (220, options_draw_cursor, r);
M_Print (16, options_draw_cursor+=8, " Brightness");
r = (1.0 - v_gamma.value) / 0.5;
r = (1.0 - v_gamma->value) / 0.5;
M_DrawSlider (220, options_draw_cursor, r);
M_Print (16, options_draw_cursor+=8, " Mouse Speed");
r = (sensitivity.value - 1)/10;
r = (sensitivity->value - 1)/10;
M_DrawSlider (220, 72, r);
M_Print (16, options_draw_cursor+=8, " CD Music Volume");
r = bgmvolume.value;
r = bgmvolume->value;
M_DrawSlider (220, options_draw_cursor, r);
M_Print (16, options_draw_cursor+=8, " Sound Volume");
r = volume.value;
r = volume->value;
M_DrawSlider (220, options_draw_cursor, r);
M_Print (16, options_draw_cursor+=8, " Always Run");
M_DrawCheckbox (220, options_draw_cursor, cl_forwardspeed.value
M_DrawCheckbox (220, options_draw_cursor, cl_forwardspeed->value
> 200);
M_Print (16, options_draw_cursor+=8, " Invert Mouse");
M_DrawCheckbox (220, options_draw_cursor, m_pitch.value < 0);
M_DrawCheckbox (220, options_draw_cursor, m_pitch->value < 0);
M_Print (16, options_draw_cursor+=8, " Lookspring");
M_DrawCheckbox (220, options_draw_cursor, lookspring.value);
M_DrawCheckbox (220, options_draw_cursor, lookspring->value);
M_Print (16, options_draw_cursor+=8, " Lookstrafe");
M_DrawCheckbox (220, options_draw_cursor, lookstrafe.value);
M_DrawCheckbox (220, options_draw_cursor, lookstrafe->value);
M_Print (16, options_draw_cursor+=8, " Use old status bar");
M_DrawCheckbox (220, options_draw_cursor, cl_sbar.value);
M_DrawCheckbox (220, options_draw_cursor, cl_sbar->value);
M_Print (16, options_draw_cursor+=8, " HUD on left side");
M_DrawCheckbox (220, options_draw_cursor, cl_hudswap.value);
M_DrawCheckbox (220, options_draw_cursor, cl_hudswap->value);
//VID_ExtraOptionDraw(options_draw_cursor);
options_draw_cursor+=VID_options_items*8;

110
qw_client/screen.c
View file

@ -95,15 +95,24 @@ float scr_conlines; // lines of console to display
float oldscreensize, oldfov;
float oldsbar;
cvar_t scr_viewsize = {"viewsize","100", CVAR_ARCHIVE};
cvar_t scr_fov = {"fov","90"}; // 10 - 170
cvar_t scr_conspeed = {"scr_conspeed","300"};
cvar_t scr_centertime = {"scr_centertime","2"};
cvar_t scr_showram = {"showram","1"};
cvar_t scr_showturtle = {"showturtle","0"};
cvar_t scr_showpause = {"showpause","1"};
cvar_t scr_printspeed = {"scr_printspeed","8"};
cvar_t scr_allowsnap = {"scr_allowsnap", "1"};
//cvar_t scr_viewsize = {"viewsize","100", CVAR_ARCHIVE};
cvar_t *scr_viewsize;
//cvar_t scr_fov = {"fov","90"}; // 10 - 170
cvar_t *scr_fov;
//cvar_t scr_conspeed = {"scr_conspeed","300"};
cvar_t *scr_conspeed;
//cvar_t scr_centertime = {"scr_centertime","2"};
cvar_t *scr_centertime;
//cvar_t scr_showram = {"showram","1"};
cvar_t *scr_showram;
//cvar_t scr_showturtle = {"showturtle","0"};
cvar_t *scr_showturtle;
//cvar_t scr_showpause = {"showpause","1"};
cvar_t *scr_showpause;
//cvar_t scr_printspeed = {"scr_printspeed","8"};
cvar_t *scr_printspeed;
//cvar_t scr_allowsnap = {"scr_allowsnap", "1"};
cvar_t *scr_allowsnap;
qboolean scr_initialized; // ready to draw
@ -158,7 +167,7 @@ for a few moments
void SCR_CenterPrint (char *str)
{
strncpy (scr_centerstring, str, sizeof(scr_centerstring)-1);
scr_centertime_off = scr_centertime.value;
scr_centertime_off = scr_centertime->value;
scr_centertime_start = cl.time;
// count the number of lines for centering
@ -200,7 +209,7 @@ void SCR_DrawCenterString (void)
// the finale prints the characters one at a time
if (cl.intermission)
remaining = scr_printspeed.value * (cl.time - scr_centertime_start);
remaining = scr_printspeed->value * (cl.time - scr_centertime_start);
else
remaining = 9999;
@ -299,25 +308,25 @@ static void SCR_CalcRefdef (void)
//========================================
// bound viewsize
if (scr_viewsize.value < 30)
if (scr_viewsize->value < 30)
Cvar_Set ("viewsize","30");
if (scr_viewsize.value > 120)
if (scr_viewsize->value > 120)
Cvar_Set ("viewsize","120");
// bound field of view
if (scr_fov.value < 10)
if (scr_fov->value < 10)
Cvar_Set ("fov","10");
if (scr_fov.value > 170)
if (scr_fov->value > 170)
Cvar_Set ("fov","170");
r_refdef.fov_x = scr_fov.value;
r_refdef.fov_x = scr_fov->value;
r_refdef.fov_y = CalcFov (r_refdef.fov_x, r_refdef.vrect.width, r_refdef.vrect.height);
// intermission is always full screen
if (cl.intermission)
size = 120;
else
size = scr_viewsize.value;
size = scr_viewsize->value;
if (size >= 120)
sb_lines = 0; // no status bar at all
@ -354,8 +363,8 @@ Keybinding command
*/
void SCR_SizeUp_f (void)
{
if (scr_viewsize.value < 120) {
Cvar_SetValue ("viewsize",scr_viewsize.value+10);
if (scr_viewsize->value < 120) {
scr_viewsize->value = scr_viewsize->value+10;
vid.recalc_refdef = 1;
}
}
@ -370,7 +379,7 @@ Keybinding command
*/
void SCR_SizeDown_f (void)
{
Cvar_SetValue ("viewsize",scr_viewsize.value-10);
scr_viewsize->value = scr_viewsize->value-10;
vid.recalc_refdef = 1;
}
@ -383,15 +392,24 @@ SCR_Init
*/
void SCR_Init (void)
{
Cvar_RegisterVariable (&scr_fov);
Cvar_RegisterVariable (&scr_viewsize);
Cvar_RegisterVariable (&scr_conspeed);
Cvar_RegisterVariable (&scr_showram);
Cvar_RegisterVariable (&scr_showturtle);
Cvar_RegisterVariable (&scr_showpause);
Cvar_RegisterVariable (&scr_centertime);
Cvar_RegisterVariable (&scr_printspeed);
Cvar_RegisterVariable (&scr_allowsnap);
// Cvar_RegisterVariable (&scr_fov);
scr_fov = Cvar_Get ("fov","90",0,"None");
// Cvar_RegisterVariable (&scr_viewsize);
scr_viewsize = Cvar_Get ("viewsize","100",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&scr_conspeed);
scr_conspeed = Cvar_Get ("scr_conspeed","300",0,"None");
// Cvar_RegisterVariable (&scr_showram);
scr_showram = Cvar_Get ("showram","1",0,"None");
// Cvar_RegisterVariable (&scr_showturtle);
scr_showturtle = Cvar_Get ("showturtle","0",0,"None");
// Cvar_RegisterVariable (&scr_showpause);
scr_showpause = Cvar_Get ("showpause","1",0,"None");
// Cvar_RegisterVariable (&scr_centertime);
scr_centertime = Cvar_Get ("scr_centertime","2",0,"None");
// Cvar_RegisterVariable (&scr_printspeed);
scr_printspeed = Cvar_Get ("scr_printspeed","8",0,"None");
// Cvar_RegisterVariable (&scr_allowsnap);
scr_allowsnap = Cvar_Get ("scr_allowsnap","1",0,"None");
//
// register our commands
@ -417,7 +435,7 @@ SCR_DrawRam
*/
void SCR_DrawRam (void)
{
if (!scr_showram.value)
if (!scr_showram->value)
return;
if (!r_cache_thrash)
@ -435,7 +453,7 @@ void SCR_DrawTurtle (void)
{
static int count;
if (!scr_showturtle.value)
if (!scr_showturtle->value)
return;
if (host_frametime < 0.1)
@ -468,7 +486,7 @@ void SCR_DrawNet (void)
void SCR_DrawFPS (void)
{
extern cvar_t show_fps;
extern cvar_t *show_fps;
static double lastframetime;
double t;
extern int fps_count;
@ -476,7 +494,7 @@ void SCR_DrawFPS (void)
int x, y;
char st[80];
if (!show_fps.value)
if (!show_fps->value)
return;
t = Sys_DoubleTime();
@ -502,7 +520,7 @@ void SCR_DrawPause (void)
{
qpic_t *pic;
if (!scr_showpause.value) // turn off for screenshots
if (!scr_showpause->value) // turn off for screenshots
return;
if (!cl.paused)
@ -539,14 +557,14 @@ void SCR_SetUpToDrawConsole (void)
if (scr_conlines < scr_con_current)
{
scr_con_current -= scr_conspeed.value * host_frametime * 4;
scr_con_current -= scr_conspeed->value * host_frametime * 4;
if (scr_conlines > scr_con_current)
scr_con_current = scr_conlines;
}
else if (scr_conlines > scr_con_current)
{
scr_con_current += scr_conspeed.value * host_frametime * 4;
scr_con_current += scr_conspeed->value * host_frametime * 4;
if (scr_conlines < scr_con_current)
scr_con_current = scr_conlines;
}
@ -814,7 +832,7 @@ void SCR_RSShot_f (void)
if (cls.state < ca_onserver)
return; // gotta be connected
if (!scr_allowsnap.value) {
if (!scr_allowsnap->value) {
MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
SZ_Print (&cls.netchan.message, "snap\n");
Con_Printf("Refusing remote screen shot request.\n");
@ -898,7 +916,7 @@ void SCR_RSShot_f (void)
st[sizeof(st) - 1] = 0;
SCR_DrawStringToSnap (st, newbuf, w - strlen(st)*8, 10, w);
strncpy(st, name.string, sizeof(st));
strncpy(st, name->string, sizeof(st));
st[sizeof(st) - 1] = 0;
SCR_DrawStringToSnap (st, newbuf, w - strlen(st)*8, 20, w);
@ -1044,30 +1062,30 @@ void SCR_UpdateScreen (void)
if (!scr_initialized || !con_initialized)
return; // not initialized yet
if (scr_viewsize.value != oldscr_viewsize)
if (scr_viewsize->value != oldscr_viewsize)
{
oldscr_viewsize = scr_viewsize.value;
oldscr_viewsize = scr_viewsize->value;
vid.recalc_refdef = 1;
}
//
// check for vid changes
//
if (oldfov != scr_fov.value)
if (oldfov != scr_fov->value)
{
oldfov = scr_fov.value;
oldfov = scr_fov->value;
vid.recalc_refdef = true;
}
if (oldscreensize != scr_viewsize.value)
if (oldscreensize != scr_viewsize->value)
{
oldscreensize = scr_viewsize.value;
oldscreensize = scr_viewsize->value;
vid.recalc_refdef = true;
}
if (oldsbar != cl_sbar.value)
if (oldsbar != cl_sbar->value)
{
oldsbar = cl_sbar.value;
oldsbar = cl_sbar->value;
vid.recalc_refdef = true;
}

221
qw_client/view.c
View file

@ -40,37 +40,59 @@ when crossing a water boudnary.
*/
cvar_t lcd_x = {"lcd_x", "0"}; // FIXME: make this work sometime...
//cvar_t lcd_x = {"lcd_x", "0"}; // FIXME: make this work sometime...
cvar_t *lcd_x;
cvar_t cl_rollspeed = {"cl_rollspeed", "200"};
cvar_t cl_rollangle = {"cl_rollangle", "2.0"};
//cvar_t cl_rollspeed = {"cl_rollspeed", "200"};
cvar_t *cl_rollspeed;
//cvar_t cl_rollangle = {"cl_rollangle", "2.0"};
cvar_t *cl_rollangle;
cvar_t cl_bob = {"cl_bob","0.02", CVAR_NONE};
cvar_t cl_bobcycle = {"cl_bobcycle","0.6", CVAR_NONE};
cvar_t cl_bobup = {"cl_bobup","0.5", CVAR_NONE};
//cvar_t cl_bob = {"cl_bob","0.02", CVAR_NONE};
cvar_t *cl_bob;
//cvar_t cl_bobcycle = {"cl_bobcycle","0.6", CVAR_NONE};
cvar_t *cl_bobcycle;
//cvar_t cl_bobup = {"cl_bobup","0.5", CVAR_NONE};
cvar_t *cl_bobup;
cvar_t v_kicktime = {"v_kicktime", "0.5", CVAR_NONE};
cvar_t v_kickroll = {"v_kickroll", "0.6", CVAR_NONE};
cvar_t v_kickpitch = {"v_kickpitch", "0.6", CVAR_NONE};
//cvar_t v_kicktime = {"v_kicktime", "0.5", CVAR_NONE};
cvar_t *v_kicktime;
//cvar_t v_kickroll = {"v_kickroll", "0.6", CVAR_NONE};
cvar_t *v_kickroll;
//cvar_t v_kickpitch = {"v_kickpitch", "0.6", CVAR_NONE};
cvar_t *v_kickpitch;
cvar_t v_iyaw_cycle = {"v_iyaw_cycle", "2", CVAR_NONE};
cvar_t v_iroll_cycle = {"v_iroll_cycle", "0.5", CVAR_NONE};
cvar_t v_ipitch_cycle = {"v_ipitch_cycle", "1", CVAR_NONE};
cvar_t v_iyaw_level = {"v_iyaw_level", "0.3", CVAR_NONE};
cvar_t v_iroll_level = {"v_iroll_level", "0.1", CVAR_NONE};
cvar_t v_ipitch_level = {"v_ipitch_level", "0.3", CVAR_NONE};
//cvar_t v_iyaw_cycle = {"v_iyaw_cycle", "2", CVAR_NONE};
cvar_t *v_iyaw_cycle;
//cvar_t v_iroll_cycle = {"v_iroll_cycle", "0.5", CVAR_NONE};
cvar_t *v_iroll_cycle;
//cvar_t v_ipitch_cycle = {"v_ipitch_cycle", "1", CVAR_NONE};
cvar_t *v_ipitch_cycle;
//cvar_t v_iyaw_level = {"v_iyaw_level", "0.3", CVAR_NONE};
cvar_t *v_iyaw_level;
//cvar_t v_iroll_level = {"v_iroll_level", "0.1", CVAR_NONE};
cvar_t *v_iroll_level;
//cvar_t v_ipitch_level = {"v_ipitch_level", "0.3", CVAR_NONE};
cvar_t *v_ipitch_level;
cvar_t v_idlescale = {"v_idlescale", "0", CVAR_NONE};
//cvar_t v_idlescale = {"v_idlescale", "0", CVAR_NONE};
cvar_t *v_idlescale;
cvar_t crosshair = {"crosshair", "0", CVAR_ARCHIVE};
cvar_t crosshaircolor = {"crosshaircolor", "79", CVAR_ARCHIVE};
//cvar_t crosshair = {"crosshair", "0", CVAR_ARCHIVE};
cvar_t *crosshair;
//cvar_t crosshaircolor = {"crosshaircolor", "79", CVAR_ARCHIVE};
cvar_t *crosshaircolor;
cvar_t cl_crossx = {"cl_crossx", "0", CVAR_ARCHIVE};
cvar_t cl_crossy = {"cl_crossy", "0", CVAR_ARCHIVE};
//cvar_t cl_crossx = {"cl_crossx", "0", CVAR_ARCHIVE};
cvar_t *cl_crossx;
//cvar_t cl_crossy = {"cl_crossy", "0", CVAR_ARCHIVE};
cvar_t *cl_crossy;
cvar_t gl_cshiftpercent = {"gl_cshiftpercent", "100", CVAR_NONE};
//cvar_t gl_cshiftpercent = {"gl_cshiftpercent", "100", CVAR_NONE};
cvar_t *gl_cshiftpercent;
cvar_t v_contentblend = {"v_contentblend", "1", CVAR_NONE};
// cvar_t v_contentblend = {"v_contentblend", "1", CVAR_NONE};
cvar_t *v_contentblend;
float v_dmg_time, v_dmg_roll, v_dmg_pitch;
@ -97,10 +119,10 @@ float V_CalcRoll (vec3_t angles, vec3_t velocity)
sign = side < 0 ? -1 : 1;
side = fabs(side);
value = cl_rollangle.value;
value = cl_rollangle->value;
if (side < cl_rollspeed.value)
side = side * value / cl_rollspeed.value;
if (side < cl_rollspeed->value)
side = side * value / cl_rollspeed->value;
else
side = value;
@ -128,17 +150,17 @@ float V_CalcBob (void)
return bob; // just use old value
bobtime += host_frametime;
cycle = bobtime - (int)(bobtime/cl_bobcycle.value)*cl_bobcycle.value;
cycle /= cl_bobcycle.value;
if (cycle < cl_bobup.value)
cycle = M_PI * cycle / cl_bobup.value;
cycle = bobtime - (int)(bobtime/cl_bobcycle->value)*cl_bobcycle->value;
cycle /= cl_bobcycle->value;
if (cycle < cl_bobup->value)
cycle = M_PI * cycle / cl_bobup->value;
else
cycle = M_PI + M_PI*(cycle-cl_bobup.value)/(1.0 - cl_bobup.value);
cycle = M_PI + M_PI*(cycle-cl_bobup->value)/(1.0 - cl_bobup->value);
// bob is proportional to simulated velocity in the xy plane
// (don't count Z, or jumping messes it up)
bob = sqrt(cl.simvel[0]*cl.simvel[0] + cl.simvel[1]*cl.simvel[1]) * cl_bob.value;
bob = sqrt(cl.simvel[0]*cl.simvel[0] + cl.simvel[1]*cl.simvel[1]) * cl_bob->value;
bob = bob*0.3 + bob*0.7*sin(cycle);
if (bob > 4)
bob = 4;
@ -152,8 +174,10 @@ float V_CalcBob (void)
//=============================================================================
cvar_t v_centermove = {"v_centermove", "0.15", CVAR_NONE};
cvar_t v_centerspeed = {"v_centerspeed","500"};
//cvar_t v_centermove = {"v_centermove", "0.15", CVAR_NONE};
cvar_t *v_centermove;
//cvar_t v_centerspeed = {"v_centerspeed","500"};
cvar_t *v_centerspeed;
void V_StartPitchDrift (void)
@ -166,7 +190,7 @@ void V_StartPitchDrift (void)
#endif
if (cl.nodrift || !cl.pitchvel)
{
cl.pitchvel = v_centerspeed.value;
cl.pitchvel = v_centerspeed->value;
cl.nodrift = false;
cl.driftmove = 0;
}
@ -211,7 +235,7 @@ void V_DriftPitch (void)
else
cl.driftmove += host_frametime;
if ( cl.driftmove > v_centermove.value)
if ( cl.driftmove > v_centermove->value)
{
V_StartPitchDrift ();
}
@ -227,7 +251,7 @@ void V_DriftPitch (void)
}
move = host_frametime * cl.pitchvel;
cl.pitchvel += host_frametime * v_centerspeed.value;
cl.pitchvel += host_frametime * v_centerspeed->value;
//Con_Printf ("move: %f (%f)\n", move, host_frametime);
@ -269,7 +293,8 @@ cshift_t cshift_water = { {130,80,50}, 128 };
cshift_t cshift_slime = { {0,25,5}, 150 };
cshift_t cshift_lava = { {255,80,0}, 150 };
cvar_t v_gamma = {"gamma", "1", CVAR_ARCHIVE};
//cvar_t v_gamma = {"gamma", "1", CVAR_ARCHIVE};
cvar_t *v_gamma;
byte gammatable[256]; // palette is sent through this
@ -308,11 +333,11 @@ qboolean V_CheckGamma (void)
{
static float oldgammavalue;
if (v_gamma.value == oldgammavalue)
if (v_gamma->value == oldgammavalue)
return false;
oldgammavalue = v_gamma.value;
oldgammavalue = v_gamma->value;
BuildGammaTable (v_gamma.value);
BuildGammaTable (v_gamma->value);
vid.recalc_refdef = 1; // force a surface cache flush
return true;
@ -379,12 +404,12 @@ void V_ParseDamage (void)
AngleVectors (cl.simangles, forward, right, up);
side = DotProduct (from, right);
v_dmg_roll = count*side*v_kickroll.value;
v_dmg_roll = count*side*v_kickroll->value;
side = DotProduct (from, forward);
v_dmg_pitch = count*side*v_kickpitch.value;
v_dmg_pitch = count*side*v_kickpitch->value;
v_dmg_time = v_kicktime.value;
v_dmg_time = v_kicktime->value;
}
@ -426,7 +451,7 @@ Underwater, lava, etc each has a color shift
*/
void V_SetContentsColor (int contents)
{
if (!v_contentblend.value) {
if (!v_contentblend->value) {
cl.cshifts[CSHIFT_CONTENTS] = cshift_empty;
return;
}
@ -505,10 +530,10 @@ void V_CalcBlend (void)
for (j=0 ; j<NUM_CSHIFTS ; j++)
{
if (!gl_cshiftpercent.value)
if (!gl_cshiftpercent->value)
continue;
a2 = ((cl.cshifts[j].percent * gl_cshiftpercent.value) / 100.0) / 255.0;
a2 = ((cl.cshifts[j].percent * gl_cshiftpercent->value) / 100.0) / 255.0;
// a2 = (cl.cshifts[j].percent/2)/255.0;
if (!a2)
@ -634,13 +659,13 @@ Idle swaying
*/
void V_AddIdle (void)
{
r_refdef.viewangles[ROLL] += v_idlescale.value * sin(cl.time*v_iroll_cycle.value) * v_iroll_level.value;
r_refdef.viewangles[PITCH] += v_idlescale.value * sin(cl.time*v_ipitch_cycle.value) * v_ipitch_level.value;
r_refdef.viewangles[YAW] += v_idlescale.value * sin(cl.time*v_iyaw_cycle.value) * v_iyaw_level.value;
r_refdef.viewangles[ROLL] += v_idlescale->value * sin(cl.time*v_iroll_cycle->value) * v_iroll_level->value;
r_refdef.viewangles[PITCH] += v_idlescale->value * sin(cl.time*v_ipitch_cycle->value) * v_ipitch_level->value;
r_refdef.viewangles[YAW] += v_idlescale->value * sin(cl.time*v_iyaw_cycle->value) * v_iyaw_level->value;
cl.viewent.angles[ROLL] -= v_idlescale.value * sin(cl.time*v_iroll_cycle.value) * v_iroll_level.value;
cl.viewent.angles[PITCH] -= v_idlescale.value * sin(cl.time*v_ipitch_cycle.value) * v_ipitch_level.value;
cl.viewent.angles[YAW] -= v_idlescale.value * sin(cl.time*v_iyaw_cycle.value) * v_iyaw_level.value;
cl.viewent.angles[ROLL] -= v_idlescale->value * sin(cl.time*v_iroll_cycle->value) * v_iroll_level->value;
cl.viewent.angles[PITCH] -= v_idlescale->value * sin(cl.time*v_ipitch_cycle->value) * v_ipitch_level->value;
cl.viewent.angles[YAW] -= v_idlescale->value * sin(cl.time*v_iyaw_cycle->value) * v_iyaw_level->value;
}
@ -660,8 +685,8 @@ void V_CalcViewRoll (void)
if (v_dmg_time > 0)
{
r_refdef.viewangles[ROLL] += v_dmg_time/v_kicktime.value*v_dmg_roll;
r_refdef.viewangles[PITCH] += v_dmg_time/v_kicktime.value*v_dmg_pitch;
r_refdef.viewangles[ROLL] += v_dmg_time/v_kicktime->value*v_dmg_roll;
r_refdef.viewangles[PITCH] += v_dmg_time/v_kicktime->value*v_dmg_pitch;
v_dmg_time -= host_frametime;
}
@ -687,10 +712,10 @@ void V_CalcIntermissionRefdef (void)
view->model = NULL;
// allways idle in intermission
old = v_idlescale.value;
v_idlescale.value = 1;
old = v_idlescale->value;
v_idlescale->value = 1;
V_AddIdle ();
v_idlescale.value = old;
v_idlescale->value = old;
}
/*
@ -762,13 +787,13 @@ void V_CalcRefdef (void)
// fudge position around to keep amount of weapon visible
// roughly equal with different FOV
if (scr_viewsize.value == 110)
if (scr_viewsize->value == 110)
view->origin[2] += 1;
else if (scr_viewsize.value == 100)
else if (scr_viewsize->value == 100)
view->origin[2] += 2;
else if (scr_viewsize.value == 90)
else if (scr_viewsize->value == 90)
view->origin[2] += 1;
else if (scr_viewsize.value == 80)
else if (scr_viewsize->value == 80)
view->origin[2] += 0.5;
if (view_message->flags & (PF_GIB|PF_DEAD) )
@ -847,7 +872,7 @@ cl.simangles[ROLL] = 0; // FIXME @@@
R_PushDlights ();
R_RenderView ();
if (crosshair.value)
if (crosshair->value)
Draw_Crosshair();
}
@ -864,37 +889,61 @@ void V_Init (void)
Cmd_AddCommand ("bf", V_BonusFlash_f);
Cmd_AddCommand ("centerview", V_StartPitchDrift);
Cvar_RegisterVariable (&v_centermove);
Cvar_RegisterVariable (&v_centerspeed);
// Cvar_RegisterVariable (&v_centermove);
v_centermove = Cvar_Get ("v_centermove","0.15",0,"None");
// Cvar_RegisterVariable (&v_centerspeed);
v_centerspeed = Cvar_Get ("v_centerspeed","500",0,"None");
Cvar_RegisterVariable (&v_iyaw_cycle);
Cvar_RegisterVariable (&v_iroll_cycle);
Cvar_RegisterVariable (&v_ipitch_cycle);
Cvar_RegisterVariable (&v_iyaw_level);
Cvar_RegisterVariable (&v_iroll_level);
Cvar_RegisterVariable (&v_ipitch_level);
// Cvar_RegisterVariable (&v_iyaw_cycle);
v_iyaw_cycle = Cvar_Get ("v_iyaw_cycle","2",0,"None");
// Cvar_RegisterVariable (&v_iroll_cycle);
v_iroll_cycle = Cvar_Get ("v_iroll_cycle","0.5",0,"None");
// Cvar_RegisterVariable (&v_ipitch_cycle);
v_ipitch_cycle = Cvar_Get ("v_ipitch_cycle","1",0,"None");
// Cvar_RegisterVariable (&v_iyaw_level);
v_iyaw_level = Cvar_Get ("v_iyaw_level","0.3",0,"None");
// Cvar_RegisterVariable (&v_iroll_level);
v_iroll_level = Cvar_Get ("v_iroll_level","0.1",0,"None");
// Cvar_RegisterVariable (&v_ipitch_level);
v_ipitch_level = Cvar_Get ("v_ipitch_level","0.3",0,"None");
Cvar_RegisterVariable (&v_contentblend);
// Cvar_RegisterVariable (&v_contentblend);
v_contentblend = Cvar_Get ("v_contentblend","1",0,"None");
Cvar_RegisterVariable (&v_idlescale);
Cvar_RegisterVariable (&crosshaircolor);
Cvar_RegisterVariable (&crosshair);
Cvar_RegisterVariable (&cl_crossx);
Cvar_RegisterVariable (&cl_crossy);
Cvar_RegisterVariable (&gl_cshiftpercent);
// Cvar_RegisterVariable (&v_idlescale);
v_idlescale = Cvar_Get ("v_idlescale","0",0,"None");
// Cvar_RegisterVariable (&crosshaircolor);
crosshaircolor = Cvar_Get ("crosshaircolor","79",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&crosshair);
crosshair = Cvar_Get ("crosshair","0",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&cl_crossx);
cl_crossx = Cvar_Get ("cl_crossx","0",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&cl_crossy);
cl_crossy = Cvar_Get ("cl_crossy","0",CVAR_ARCHIVE,"None");
// Cvar_RegisterVariable (&gl_cshiftpercent);
gl_cshiftpercent = Cvar_Get ("gl_cshiftpercent","100",0,"None");
Cvar_RegisterVariable (&cl_rollspeed);
Cvar_RegisterVariable (&cl_rollangle);
Cvar_RegisterVariable (&cl_bob);
Cvar_RegisterVariable (&cl_bobcycle);
Cvar_RegisterVariable (&cl_bobup);
// Cvar_RegisterVariable (&cl_rollspeed);
cl_rollspeed = Cvar_Get ("cl_rollspeed","200",0,"None");
// Cvar_RegisterVariable (&cl_rollangle);
cl_rollangle = Cvar_Get ("cl_rollangle","2.0",0,"None");
// Cvar_RegisterVariable (&cl_bob);
cl_bob = Cvar_Get ("cl_bob","0.02",0,"None");
// Cvar_RegisterVariable (&cl_bobcycle);
cl_bobcycle = Cvar_Get ("cl_bobcycle","0.6",0,"None");
// Cvar_RegisterVariable (&cl_bobup);
cl_bobup = Cvar_Get ("cl_bobup","0.5",0,"None");
Cvar_RegisterVariable (&v_kicktime);
Cvar_RegisterVariable (&v_kickroll);
Cvar_RegisterVariable (&v_kickpitch);
// Cvar_RegisterVariable (&v_kicktime);
v_kicktime = Cvar_Get ("v_kicktime","0.5",0,"None");
// Cvar_RegisterVariable (&v_kickroll);
v_kickroll = Cvar_Get ("v_kickroll","0.6",0,"None");
// Cvar_RegisterVariable (&v_kickpitch);
v_kickpitch = Cvar_Get ("v_kickpitch","0.6",0,"None");
BuildGammaTable (1.0); // no gamma yet
Cvar_RegisterVariable (&v_gamma);
// Cvar_RegisterVariable (&v_gamma);
v_gamma = Cvar_Get ("gamma","1",CVAR_ARCHIVE,"None");
}

28
qw_common/net_chan.c
View file

@ -87,9 +87,12 @@ to the new value before sending out any replies.
*/
int net_drop;
cvar_t showpackets = {"showpackets", "0"};
cvar_t showdrop = {"showdrop", "0"};
cvar_t qport = {"qport", "0"};
//cvar_t showpackets = {"showpackets", "0"};
cvar_t *showpackets;
//cvar_t showdrop = {"showdrop", "0"};
cvar_t *showdrop;
//cvar_t qport = {"qport", "0"};
cvar_t *qport;
/*
===============
@ -108,10 +111,13 @@ void Netchan_Init (void)
port = ((int)(getpid()+getuid()*1000) * time(NULL)) & 0xffff;
#endif
Cvar_RegisterVariable (&showpackets);
Cvar_RegisterVariable (&showdrop);
Cvar_RegisterVariable (&qport);
Cvar_SetValue("qport", port);
// Cvar_RegisterVariable (&showpackets);
showpackets = Cvar_Get ("showpackets","0",0,"None");
// Cvar_RegisterVariable (&showdrop);
showdrop = Cvar_Get ("showdrop","0",0,"None");
// Cvar_RegisterVariable (&qport);
qport = Cvar_Get ("qport","0",0,"None");
qport->value = port;
}
/*
@ -314,7 +320,7 @@ void Netchan_Transmit (netchan_t *chan, int length, byte *data)
chan->cleartime = realtime;
#endif
if (showpackets.value)
if (showpackets->value)
Con_Printf ("--> s=%i(%i) a=%i(%i) %i\n"
, chan->outgoing_sequence
, send_reliable
@ -364,7 +370,7 @@ qboolean Netchan_Process (netchan_t *chan)
sequence &= ~(1<<31);
sequence_ack &= ~(1<<31);
if (showpackets.value)
if (showpackets->value)
Con_Printf ("<-- s=%i(%i) a=%i(%i) %i\n"
, sequence
, reliable_message
@ -407,7 +413,7 @@ qboolean Netchan_Process (netchan_t *chan)
//
if (sequence <= (unsigned)chan->incoming_sequence)
{
if (showdrop.value)
if (showdrop->value)
Con_Printf ("%s:Out of order packet %i at %i\n"
, NET_AdrToString (chan->remote_address)
, sequence
@ -423,7 +429,7 @@ qboolean Netchan_Process (netchan_t *chan)
{
chan->drop_count += 1;
if (showdrop.value)
if (showdrop->value)
Con_Printf ("%s:Dropped %i packets at %i\n"
, NET_AdrToString (chan->remote_address)
, sequence-(chan->incoming_sequence+1)

3
qw_common/screen.h
View file

@ -46,9 +46,8 @@ extern int sb_lines;
extern int clearnotify; // set to 0 whenever notify text is drawn
extern qboolean scr_disabled_for_loading;
extern cvar_t scr_viewsize;
extern cvar_t *scr_viewsize;
extern cvar_t scr_viewsize;
// only the refresh window will be updated unless these variables are flagged
extern int scr_copytop;

4
qw_server/sv_ccmds.c
View file

@ -39,7 +39,7 @@ qboolean sv_allow_cheats;
int fp_messages=4, fp_persecond=4, fp_secondsdead=10;
char fp_msg[255] = { 0 };
extern cvar_t cl_warncmd;
extern cvar_t *cl_warncmd;
extern redirect_t sv_redirected;
@ -939,5 +939,5 @@ void SV_InitOperatorCommands (void)
Cmd_AddCommand ("floodprotmsg", SV_Floodprotmsg_f);
Cmd_AddCommand ("fly", SV_Fly_f);
cl_warncmd.value = 1;
cl_warncmd->value = 1;
}

289
qw_server/sv_main.c
View file

@ -50,47 +50,74 @@ netadr_t master_adr[MAX_MASTERS]; // address of group servers
client_t *host_client; // current client
cvar_t sv_maxrate = {"sv_maxrate","0"}; // server maximum rate
cvar_t sv_mintic = {"sv_mintic","0.03"}; // bound the size of the
cvar_t sv_maxtic = {"sv_maxtic","0.1"}; // physics time tic
//cvar_t sv_maxrate = {"sv_maxrate","0"}; // server maximum rate
cvar_t *sv_maxrate;
//cvar_t sv_mintic = {"sv_mintic","0.03"}; // bound the size of the
cvar_t *sv_mintic;
//cvar_t sv_maxtic = {"sv_maxtic","0.1"}; // physics time tic
cvar_t *sv_maxtic;
cvar_t developer = {"developer","0"}; // show extra messages
//cvar_t developer = {"developer","0"}; // show extra messages
cvar_t *developer;
cvar_t timeout = {"timeout","65"}; // seconds without any message
cvar_t zombietime = {"zombietime", "2"}; // seconds to sink messages
//cvar_t timeout = {"timeout","65"}; // seconds without any message
cvar_t *timeout;
//cvar_t zombietime = {"zombietime", "2"}; // seconds to sink messages
cvar_t *zombietime;
// after disconnect
cvar_t rcon_password = {"rcon_password", ""}; // password for remote server commands
cvar_t password = {"password", ""}; // password for entering the game
cvar_t spectator_password = {"spectator_password", ""}; // password for entering as a sepctator
//cvar_t rcon_password = {"rcon_password", ""}; // password for remote server commands
cvar_t *rcon_password;
//cvar_t password = {"password", ""}; // password for entering the game
cvar_t *password;
//cvar_t spectator_password = {"spectator_password", ""}; // password for entering as a sepctator
cvar_t *spectator_password;
cvar_t allow_download = {"allow_download", "1"};
cvar_t allow_download_skins = {"allow_download_skins", "1"};
cvar_t allow_download_models = {"allow_download_models", "1"};
cvar_t allow_download_sounds = {"allow_download_sounds", "1"};
cvar_t allow_download_maps = {"allow_download_maps", "1"};
//cvar_t allow_download = {"allow_download", "1"};
cvar_t *allow_download;
//cvar_t allow_download_skins = {"allow_download_skins", "1"};
cvar_t *allow_download_skins;
//cvar_t allow_download_models = {"allow_download_models", "1"};
cvar_t *allow_download_models;
//cvar_t allow_download_sounds = {"allow_download_sounds", "1"};
cvar_t *allow_download_sounds;
//cvar_t allow_download_maps = {"allow_download_maps", "1"};
cvar_t *allow_download_maps;
cvar_t sv_highchars = {"sv_highchars", "1"};
//cvar_t sv_highchars = {"sv_highchars", "1"};
cvar_t *sv_highchars;
cvar_t sv_phs = {"sv_phs", "1"};
//cvar_t sv_phs = {"sv_phs", "1"};
cvar_t *sv_phs;
cvar_t pausable = {"pausable", "1"};
//cvar_t pausable = {"pausable", "1"};
cvar_t *pausable;
//
// game rules mirrored in svs.info
//
cvar_t fraglimit = {"fraglimit","0",CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t timelimit = {"timelimit","0",CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t teamplay = {"teamplay","0",CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t samelevel = {"samelevel","0", CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t maxclients = {"maxclients","8", CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t maxspectators = {"maxspectators","8", CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t deathmatch = {"deathmatch","1", CVAR_USERINFO|CVAR_SERVERINFO}; // 0, 1, or 2
cvar_t spawn = {"spawn","0", CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t watervis = {"watervis", "0", CVAR_USERINFO|CVAR_SERVERINFO};
//cvar_t fraglimit = {"fraglimit","0",CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *fraglimit;
//cvar_t timelimit = {"timelimit","0",CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *timelimit;
//cvar_t teamplay = {"teamplay","0",CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *teamplay;
//cvar_t samelevel = {"samelevel","0", CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *samelevel;
//cvar_t maxclients = {"maxclients","8", CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *maxclients;
//cvar_t maxspectators = {"maxspectators","8", CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *maxspectators;
//cvar_t deathmatch = {"deathmatch","1", CVAR_USERINFO|CVAR_SERVERINFO}; // 0, 1, or 2
cvar_t *deathmatch;
//cvar_t spawn = {"spawn","0", CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *spawn;
//cvar_t watervis = {"watervis", "0", CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *watervis;
cvar_t hostname = {"hostname","unnamed", CVAR_USERINFO|CVAR_SERVERINFO};
//cvar_t hostname = {"hostname","unnamed", CVAR_USERINFO|CVAR_SERVERINFO};
cvar_t *hostname;
QFile *sv_logfile;
QFile *sv_fraglogfile;
@ -572,9 +599,9 @@ void SVC_DirectConnect (void)
s = Info_ValueForKey (userinfo, "spectator");
if (s[0] && strcmp(s, "0"))
{
if (spectator_password.string[0] &&
stricmp(spectator_password.string, "none") &&
strcmp(spectator_password.string, s) )
if (spectator_password->string[0] &&
stricmp(spectator_password->string, "none") &&
strcmp(spectator_password->string, s) )
{ // failed
Con_Printf ("%s:spectator password failed\n", NET_AdrToString (net_from));
Netchan_OutOfBandPrint (net_from, "%c\nrequires a spectator password\n\n", A2C_PRINT);
@ -587,9 +614,9 @@ void SVC_DirectConnect (void)
else
{
s = Info_ValueForKey (userinfo, "password");
if (password.string[0] &&
stricmp(password.string, "none") &&
strcmp(password.string, s) )
if (password->string[0] &&
stricmp(password->string, "none") &&
strcmp(password->string, s) )
{
Con_Printf ("%s:password failed\n", NET_AdrToString (net_from));
Netchan_OutOfBandPrint (net_from, "%c\nserver requires a password\n\n", A2C_PRINT);
@ -608,7 +635,7 @@ void SVC_DirectConnect (void)
newcl->userid = userid;
// works properly
if (!sv_highchars.value) {
if (!sv_highchars->value) {
byte *p, *q;
for (p = (byte *)newcl->userinfo, q = (byte *)userinfo;
@ -653,14 +680,14 @@ void SVC_DirectConnect (void)
}
// if at server limits, refuse connection
if ( maxclients.value > MAX_CLIENTS )
Cvar_SetValue ("maxclients", MAX_CLIENTS);
if (maxspectators.value > MAX_CLIENTS)
Cvar_SetValue ("maxspectators", MAX_CLIENTS);
if (maxspectators.value + maxclients.value > MAX_CLIENTS)
Cvar_SetValue ("maxspectators", MAX_CLIENTS - maxspectators.value + maxclients.value);
if ( (spectator && spectators >= (int)maxspectators.value)
|| (!spectator && clients >= (int)maxclients.value) )
if ( maxclients->value > MAX_CLIENTS )
maxclients->value = MAX_CLIENTS;
if (maxspectators->value > MAX_CLIENTS)
maxspectators->value = MAX_CLIENTS;
if (maxspectators->value + maxclients->value > MAX_CLIENTS)
maxspectators->value = (MAX_CLIENTS - maxspectators->value + maxclients->value);
if ( (spectator && spectators >= (int)maxspectators->value)
|| (!spectator && clients >= (int)maxclients->value) )
{
Con_Printf ("%s:full connect\n", NET_AdrToString (adr));
Netchan_OutOfBandPrint (adr, "%c\nserver is full\n\n", A2C_PRINT);
@ -735,10 +762,10 @@ void SVC_DirectConnect (void)
int Rcon_Validate (void)
{
if (!strlen (rcon_password.string))
if (!strlen (rcon_password->string))
return 0;
if (strcmp (Cmd_Argv(1), rcon_password.string) )
if (strcmp (Cmd_Argv(1), rcon_password->string) )
return 0;
return 1;
@ -894,7 +921,8 @@ typedef struct
ipfilter_t ipfilters[MAX_IPFILTERS];
int numipfilters;
cvar_t filterban = {"filterban", "1"};
//cvar_t filterban = {"filterban", "1"};
cvar_t *filterban;
/*
=================
@ -1075,9 +1103,9 @@ qboolean SV_FilterPacket (void)
for (i=0 ; i<numipfilters ; i++)
if ( (in & ipfilters[i].mask) == ipfilters[i].compare)
return filterban.value;
return filterban->value;
return !filterban.value;
return !filterban->value;
}
//============================================================================
@ -1155,7 +1183,7 @@ void SV_ReadPackets (void)
==================
SV_CheckTimeouts
If a packet has not been received from a client in timeout.value
If a packet has not been received from a client in timeout->value
seconds, drop the conneciton.
When a client is normally dropped, the client_t goes into a zombie state
@ -1170,7 +1198,7 @@ void SV_CheckTimeouts (void)
float droptime;
int nclients;
droptime = realtime - timeout.value;
droptime = realtime - timeout->value;
nclients = 0;
for (i=0,cl=svs.clients ; i<MAX_CLIENTS ; i++,cl++)
@ -1185,7 +1213,7 @@ void SV_CheckTimeouts (void)
}
}
if (cl->state == cs_zombie &&
realtime - cl->connection_started > zombietime.value)
realtime - cl->connection_started > zombietime->value)
{
cl->state = cs_free; // can now be reused
}
@ -1227,10 +1255,10 @@ void SV_CheckVars (void)
static char *pw, *spw;
int v;
if (password.string == pw && spectator_password.string == spw)
if (password->string == pw && spectator_password->string == spw)
return;
pw = password.string;
spw = spectator_password.string;
pw = password->string;
spw = spectator_password->string;
v = 0;
if (pw && pw[0] && strcmp(pw, "none"))
@ -1317,70 +1345,121 @@ SV_InitLocal
void SV_InitLocal (void)
{
int i;
extern cvar_t sv_maxvelocity;
extern cvar_t sv_gravity;
extern cvar_t sv_aim;
extern cvar_t sv_stopspeed;
extern cvar_t sv_spectatormaxspeed;
extern cvar_t sv_accelerate;
extern cvar_t sv_airaccelerate;
extern cvar_t sv_wateraccelerate;
extern cvar_t sv_friction;
extern cvar_t sv_waterfriction;
extern cvar_t *sv_maxvelocity;
extern cvar_t *sv_gravity;
extern cvar_t *sv_aim;
extern cvar_t *sv_stopspeed;
extern cvar_t *sv_spectatormaxspeed;
extern cvar_t *sv_accelerate;
extern cvar_t *sv_airaccelerate;
extern cvar_t *sv_wateraccelerate;
extern cvar_t *sv_friction;
extern cvar_t *sv_waterfriction;
SV_InitOperatorCommands ();
SV_UserInit ();
Cvar_RegisterVariable (&rcon_password);
Cvar_RegisterVariable (&password);
Cvar_RegisterVariable (&spectator_password);
// Cvar_RegisterVariable (&rcon_password);
rcon_password = Cvar_Get ("rcon_password","",CVAR_NONE,
"Password for remote server commands");
// Cvar_RegisterVariable (&password);
password = Cvar_Get ("password","",CVAR_NONE,
"Password for entering the game");
// Cvar_RegisterVariable (&spectator_password);
spectator_password = Cvar_Get ("spectator_password","",CVAR_NONE,
"Password for entering as a spectator");
Cvar_RegisterVariable (&sv_mintic);
Cvar_RegisterVariable (&sv_maxtic);
// Cvar_RegisterVariable (&sv_mintic);
sv_mintic = Cvar_Get ("sv_mintic","0.3",0,"None");
// Cvar_RegisterVariable (&sv_maxtic);
sv_maxtic = Cvar_Get ("sv_maxtic","0.1",0,"None");
Cvar_RegisterVariable (&fraglimit);
Cvar_RegisterVariable (&timelimit);
Cvar_RegisterVariable (&teamplay);
Cvar_RegisterVariable (&samelevel);
Cvar_RegisterVariable (&maxclients);
Cvar_RegisterVariable (&maxspectators);
Cvar_RegisterVariable (&hostname);
Cvar_RegisterVariable (&deathmatch);
Cvar_RegisterVariable (&spawn);
Cvar_RegisterVariable (&watervis);
// Cvar_RegisterVariable (&fraglimit);
fraglimit = Cvar_Get ("fraglimit","0",CVAR_USERINFO|CVAR_SERVERINFO,
"None");
// Cvar_RegisterVariable (&timelimit);
timelimit = Cvar_Get ("timelimit","0",CVAR_USERINFO|CVAR_SERVERINFO,
"None");
// Cvar_RegisterVariable (&teamplay);
teamplay = Cvar_Get ("teamplay","0",CVAR_USERINFO|CVAR_SERVERINFO,
"None");
// Cvar_RegisterVariable (&samelevel);
samelevel = Cvar_Get ("samelevel","0",CVAR_USERINFO|CVAR_SERVERINFO,
"None");
// Cvar_RegisterVariable (&maxclients);
maxclients = Cvar_Get ("maxclients","8",CVAR_USERINFO|CVAR_SERVERINFO,
"None");
// Cvar_RegisterVariable (&maxspectators);
maxspectators = Cvar_Get ("maxspectators","8",
CVAR_USERINFO|CVAR_SERVERINFO,"None");
// Cvar_RegisterVariable (&hostname);
hostname = Cvar_Get ("hostname","unnamed",
CVAR_USERINFO|CVAR_SERVERINFO,"None");
// Cvar_RegisterVariable (&deathmatch);
deathmatch = Cvar_Get ("deathmatch","1",CVAR_USERINFO|CVAR_SERVERINFO,
"None");
// Cvar_RegisterVariable (&spawn);
spawn = Cvar_Get ("spawn","0",CVAR_USERINFO|CVAR_SERVERINFO,"None");
// Cvar_RegisterVariable (&watervis);
watervis = Cvar_Get ("watervis","0",CVAR_USERINFO|CVAR_SERVERINFO,
"None");
Cvar_RegisterVariable (&sv_maxrate);
Cvar_RegisterVariable (&developer);
// Cvar_RegisterVariable (&sv_maxrate);
sv_maxrate = Cvar_Get ("sv_maxrate","0",0,"None");
// Cvar_RegisterVariable (&developer);
developer = Cvar_Get ("developer","0",0,"None");
Cvar_RegisterVariable (&timeout);
Cvar_RegisterVariable (&zombietime);
// Cvar_RegisterVariable (&timeout);
timeout = Cvar_Get ("timeout","65",0,"None");
// Cvar_RegisterVariable (&zombietime);
zombietime = Cvar_Get ("zombietime","2",0,"None");
Cvar_RegisterVariable (&sv_maxvelocity);
Cvar_RegisterVariable (&sv_gravity);
Cvar_RegisterVariable (&sv_stopspeed);
Cvar_RegisterVariable (&sv_maxspeed);
Cvar_RegisterVariable (&sv_spectatormaxspeed);
Cvar_RegisterVariable (&sv_accelerate);
Cvar_RegisterVariable (&sv_airaccelerate);
Cvar_RegisterVariable (&sv_wateraccelerate);
Cvar_RegisterVariable (&sv_friction);
Cvar_RegisterVariable (&sv_waterfriction);
// Cvar_RegisterVariable (&sv_maxvelocity);
sv_maxvelocity = Cvar_Get ("sv_maxvelocity","2000",0,"None");
// Cvar_RegisterVariable (&sv_gravity);
sv_gravity = Cvar_Get ("sv_gravity","800",0,"None");
// Cvar_RegisterVariable (&sv_stopspeed);
sv_stopspeed = Cvar_Get ("sv_stopspeed","100",0,"None");
// Cvar_RegisterVariable (&sv_maxspeed);
sv_maxspeed = Cvar_Get ("sv_maxspeed","320",0,"None");
// Cvar_RegisterVariable (&sv_spectatormaxspeed);
sv_spectatormaxspeed = Cvar_Get ("sv_spectatormaxspeed","500",0,
"None");
// Cvar_RegisterVariable (&sv_accelerate);
sv_accelerate = Cvar_Get ("sv_accelerate","10",0,"None");
// Cvar_RegisterVariable (&sv_airaccelerate);
sv_airaccelerate = Cvar_Get ("sv_airaccelerate","0.7",0,"None");
// Cvar_RegisterVariable (&sv_wateraccelerate);
sv_wateraccelerate = Cvar_Get ("sv_wateraccelerate","10",0,"None");
// Cvar_RegisterVariable (&sv_friction);
sv_friction = Cvar_Get ("sv_friction","4",0,"None");
// Cvar_RegisterVariable (&sv_waterfriction);
sv_waterfriction = Cvar_Get ("sv_waterfriction","4",0,"None");
Cvar_RegisterVariable (&sv_aim);
Cvar_RegisterVariable (&filterban);
// Cvar_RegisterVariable (&sv_aim);
sv_aim = Cvar_Get ("sv_aim","2",0,"None");
// Cvar_RegisterVariable (&filterban);
filterban = Cvar_Get ("filterban","1",0,"None");
Cvar_RegisterVariable (&allow_download);
Cvar_RegisterVariable (&allow_download_skins);
Cvar_RegisterVariable (&allow_download_models);
Cvar_RegisterVariable (&allow_download_sounds);
Cvar_RegisterVariable (&allow_download_maps);
// Cvar_RegisterVariable (&allow_download);
allow_download = Cvar_Get ("allow_download","1",0,"None");
// Cvar_RegisterVariable (&allow_download_skins);
allow_download_skins = Cvar_Get ("allow_download_skins","1",0,"None");
// Cvar_RegisterVariable (&allow_download_models);
allow_download_models = Cvar_Get ("allow_download_models","1",0,"None");
// Cvar_RegisterVariable (&allow_download_sounds);
allow_download_sounds = Cvar_Get ("allow_download_sounds","1",0,"None");
// Cvar_RegisterVariable (&allow_download_maps);
allow_download_maps = Cvar_Get ("allow_download_maps","1",0,"None");
Cvar_RegisterVariable (&sv_highchars);
// Cvar_RegisterVariable (&sv_highchars);
sv_highchars = Cvar_Get ("sv_highchars","1",0,"None");
Cvar_RegisterVariable (&sv_phs);
// Cvar_RegisterVariable (&sv_phs);
sv_phs = Cvar_Get ("sv_phs","1",0,"None");
Cvar_RegisterVariable (&pausable);
// Cvar_RegisterVariable (&pausable);
pausable = Cvar_Get ("pausable","1",0,"None");
Cmd_AddCommand ("addip", SV_AddIP_f);
Cmd_AddCommand ("removeip", SV_RemoveIP_f);
@ -1422,9 +1501,9 @@ void HeartBeat_Check( void) {
// Put stuff in here that you want done to every client
// Slades maxrate function
if((1/cl->netchan.rate) > sv_maxrate.value && sv_maxrate.value) {
if((1/cl->netchan.rate) > sv_maxrate->value && sv_maxrate->value) {
SV_BroadcastPrintf (PRINT_HIGH, "%s was kicked for having his rate to high\n", cl->name);
SV_ClientPrintf (cl, PRINT_HIGH, "You were kicked from the game for having a rate higher then %5.0f\n", sv_maxrate.value);
SV_ClientPrintf (cl, PRINT_HIGH, "You were kicked from the game for having a rate higher then %5.0f\n", sv_maxrate->value);
SV_DropClient(cl);
}

62
qw_server/sv_phys.c
View file

@ -52,17 +52,27 @@ solid_edge items only clip against bsp models.
*/
cvar_t sv_maxvelocity = {"sv_maxvelocity","2000"};
//cvar_t sv_maxvelocity = {"sv_maxvelocity","2000"};
cvar_t *sv_maxvelocity;
cvar_t sv_gravity = { "sv_gravity", "800"};
cvar_t sv_stopspeed = { "sv_stopspeed", "100"};
cvar_t sv_maxspeed = { "sv_maxspeed", "320"};
cvar_t sv_spectatormaxspeed = { "sv_spectatormaxspeed", "500"};
cvar_t sv_accelerate = { "sv_accelerate", "10"};
cvar_t sv_airaccelerate = { "sv_airaccelerate", "0.7"};
cvar_t sv_wateraccelerate = { "sv_wateraccelerate", "10"};
cvar_t sv_friction = { "sv_friction", "4"};
cvar_t sv_waterfriction = { "sv_waterfriction", "4"};
//cvar_t sv_gravity = { "sv_gravity", "800"};
cvar_t *sv_gravity;
//cvar_t sv_stopspeed = { "sv_stopspeed", "100"};
cvar_t *sv_stopspeed;
//cvar_t sv_maxspeed = { "sv_maxspeed", "320"};
cvar_t *sv_maxspeed;
//cvar_t sv_spectatormaxspeed = { "sv_spectatormaxspeed", "500"};
cvar_t *sv_spectatormaxspeed;
//cvar_t sv_accelerate = { "sv_accelerate", "10"};
cvar_t *sv_accelerate;
//cvar_t sv_airaccelerate = { "sv_airaccelerate", "0.7"};
cvar_t *sv_airaccelerate;
//cvar_t sv_wateraccelerate = { "sv_wateraccelerate", "10"};
cvar_t *sv_wateraccelerate;
//cvar_t sv_friction = { "sv_friction", "4"};
cvar_t *sv_friction;
//cvar_t sv_waterfriction = { "sv_waterfriction", "4"};
cvar_t *sv_waterfriction;
#define MOVE_EPSILON 0.01
@ -120,10 +130,10 @@ void SV_CheckVelocity (edict_t *ent)
Con_Printf ("Got a NaN origin on %s\n", PR_GetString(ent->v.classname));
ent->v.origin[i] = 0;
}
if (ent->v.velocity[i] > sv_maxvelocity.value)
ent->v.velocity[i] = sv_maxvelocity.value;
else if (ent->v.velocity[i] < -sv_maxvelocity.value)
ent->v.velocity[i] = -sv_maxvelocity.value;
if (ent->v.velocity[i] > sv_maxvelocity->value)
ent->v.velocity[i] = sv_maxvelocity->value;
else if (ent->v.velocity[i] < -sv_maxvelocity->value)
ent->v.velocity[i] = -sv_maxvelocity->value;
}
}
@ -916,10 +926,10 @@ void SV_Physics (void)
// don't bother running a frame if sys_ticrate seconds haven't passed
host_frametime = realtime - old_time;
if (host_frametime < sv_mintic.value)
if (host_frametime < sv_mintic->value)
return;
if (host_frametime > sv_maxtic.value)
host_frametime = sv_maxtic.value;
if (host_frametime > sv_maxtic->value)
host_frametime = sv_maxtic->value;
old_time = realtime;
pr_global_struct->frametime = host_frametime;
@ -952,14 +962,14 @@ void SV_Physics (void)
void SV_SetMoveVars(void)
{
movevars.gravity = sv_gravity.value;
movevars.stopspeed = sv_stopspeed.value;
movevars.maxspeed = sv_maxspeed.value;
movevars.spectatormaxspeed = sv_spectatormaxspeed.value;
movevars.accelerate = sv_accelerate.value;
movevars.airaccelerate = sv_airaccelerate.value;
movevars.wateraccelerate = sv_wateraccelerate.value;
movevars.friction = sv_friction.value;
movevars.waterfriction = sv_waterfriction.value;
movevars.gravity = sv_gravity->value;
movevars.stopspeed = sv_stopspeed->value;
movevars.maxspeed = sv_maxspeed->value;
movevars.spectatormaxspeed = sv_spectatormaxspeed->value;
movevars.accelerate = sv_accelerate->value;
movevars.airaccelerate = sv_airaccelerate->value;
movevars.wateraccelerate = sv_wateraccelerate->value;
movevars.friction = sv_friction->value;
movevars.waterfriction = sv_waterfriction->value;
movevars.entgravity = 1.0;
}

6
qw_server/sv_send.c
View file

@ -52,7 +52,7 @@ char outputbuf[8000];
redirect_t sv_redirected;
extern cvar_t sv_phs;
extern cvar_t *sv_phs;
/*
==================
@ -151,7 +151,7 @@ void Con_DPrintf (char *fmt, ...)
va_list argptr;
char msg[MAXPRINTMSG];
if (!developer.value)
if (!developer->value)
return;
va_start (argptr, fmt);
@ -393,7 +393,7 @@ void SV_StartSound (edict_t *entity, int channel, char *sample, int volume,
ent = NUM_FOR_EDICT(entity);
if ((channel & 8) || !sv_phs.value) // no PHS flag
if ((channel & 8) || !sv_phs->value) // no PHS flag
{
if (channel & 8)
reliable = true; // sounds that break the phs are reliable

64
qw_server/sv_user.c
View file

@ -39,17 +39,21 @@ edict_t *sv_player;
usercmd_t cmd;
cvar_t cl_rollspeed = {"cl_rollspeed", "200"};
cvar_t cl_rollangle = {"cl_rollangle", "2.0"};
cvar_t sv_spectalk = {"sv_spectalk", "1"};
//cvar_t cl_rollspeed = {"cl_rollspeed", "200"};
cvar_t *cl_rollspeed;
//cvar_t cl_rollangle = {"cl_rollangle", "2.0"};
cvar_t *cl_rollangle;
//cvar_t sv_spectalk = {"sv_spectalk", "1"};
cvar_t *sv_spectalk;
cvar_t sv_mapcheck = {"sv_mapcheck", "1"};
//cvar_t sv_mapcheck = {"sv_mapcheck", "1"};
cvar_t *sv_mapcheck;
extern vec3_t player_mins;
extern int fp_messages, fp_persecond, fp_secondsdead;
extern char fp_msg[];
extern cvar_t pausable;
extern cvar_t *pausable;
static int loss;
/*
@ -264,7 +268,7 @@ void SV_PreSpawn_f (void)
// Con_DPrintf("Client check = %d\n", check);
if (sv_mapcheck.value && check != sv.worldmodel->checksum &&
if (sv_mapcheck->value && check != sv.worldmodel->checksum &&
check != sv.worldmodel->checksum2) {
SV_ClientPrintf (host_client, PRINT_HIGH,
"Map model file does not match (%s), %i != %i/%i.\n"
@ -372,10 +376,10 @@ void SV_Spawn_f (void)
val = GetEdictFieldValue(ent, "gravity");
if (val)
val->_float = 1.0;
host_client->maxspeed = sv_maxspeed.value;
host_client->maxspeed = sv_maxspeed->value;
val = GetEdictFieldValue(ent, "maxspeed");
if (val)
val->_float = sv_maxspeed.value;
val->_float = sv_maxspeed->value;
//
// force stats to be updated
@ -656,29 +660,29 @@ SV_BeginDownload_f
void SV_BeginDownload_f(void)
{
char *name;
extern cvar_t allow_download;
extern cvar_t allow_download_skins;
extern cvar_t allow_download_models;
extern cvar_t allow_download_sounds;
extern cvar_t allow_download_maps;
extern cvar_t *allow_download;
extern cvar_t *allow_download_skins;
extern cvar_t *allow_download_models;
extern cvar_t *allow_download_sounds;
extern cvar_t *allow_download_maps;
extern int file_from_pak; // ZOID did file come from pak?
name = Cmd_Argv(1);
// hacked by zoid to allow more conrol over download
// first off, no .. or global allow check
if (strstr (name, "..") || !allow_download.value
if (strstr (name, "..") || !allow_download->value
// leading dot is no good
|| *name == '.'
// leading slash bad as well, must be in subdir
|| *name == '/'
// next up, skin check
|| (strncmp(name, "skins/", 6) == 0 && !allow_download_skins.value)
|| (strncmp(name, "skins/", 6) == 0 && !allow_download_skins->value)
// now models
|| (strncmp(name, "progs/", 6) == 0 && !allow_download_models.value)
|| (strncmp(name, "progs/", 6) == 0 && !allow_download_models->value)
// now sounds
|| (strncmp(name, "sound/", 6) == 0 && !allow_download_sounds.value)
|| (strncmp(name, "sound/", 6) == 0 && !allow_download_sounds->value)
// now maps (note special case for maps, must not be in pak)
|| (strncmp(name, "maps/", 6) == 0 && !allow_download_maps.value)
|| (strncmp(name, "maps/", 6) == 0 && !allow_download_maps->value)
// MUST be in a subdirectory
|| !strstr (name, "/") )
{ // don't allow anything with .. path
@ -750,7 +754,7 @@ void SV_Say (qboolean team)
t1[31] = 0;
}
if (host_client->spectator && (!sv_spectalk.value || team))
if (host_client->spectator && (!sv_spectalk->value || team))
snprintf(text, sizeof(text), "[SPEC] %s: ", host_client->name);
else if (team)
snprintf(text, sizeof(text), "(%s): ", host_client->name);
@ -802,7 +806,7 @@ void SV_Say (qboolean team)
{
if (client->state != cs_spawned)
continue;
if (host_client->spectator && !sv_spectalk.value)
if (host_client->spectator && !sv_spectalk->value)
if (!client->spectator)
continue;
@ -928,7 +932,7 @@ void SV_Pause_f (void)
{
char st[sizeof(host_client->name) + 32];
if (!pausable.value) {
if (!pausable->value) {
SV_ClientPrintf (host_client, PRINT_HIGH, "Pause not allowed.\n");
return;
}
@ -1221,10 +1225,10 @@ float V_CalcRoll (vec3_t angles, vec3_t velocity)
sign = side < 0 ? -1 : 1;
side = fabs(side);
value = cl_rollangle.value;
value = cl_rollangle->value;
if (side < cl_rollspeed.value)
side = side * value / cl_rollspeed.value;
if (side < cl_rollspeed->value)
side = side * value / cl_rollspeed->value;
else
side = value;
@ -1736,10 +1740,14 @@ SV_UserInit
*/
void SV_UserInit (void)
{
Cvar_RegisterVariable (&cl_rollspeed);
Cvar_RegisterVariable (&cl_rollangle);
Cvar_RegisterVariable (&sv_spectalk);
Cvar_RegisterVariable (&sv_mapcheck);
// Cvar_RegisterVariable (&cl_rollspeed);
cl_rollspeed = Cvar_Get ("cl_rollspeed","200",0,"None");
// Cvar_RegisterVariable (&cl_rollangle);
cl_rollangle = Cvar_Get ("cl_rollangle","2.0",0,"None");
// Cvar_RegisterVariable (&sv_spectalk);
sv_spectalk = Cvar_Get ("sv_spectalk","1",0,"None");
// Cvar_RegisterVariable (&sv_mapcheck);
sv_mapcheck = Cvar_Get ("sv_mapcheck","1",0,"None");
}

18
qw_server/sys_unix.c
View file

@ -65,9 +65,10 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include <server.h>
#include <sys.h>
extern cvar_t sys_nostdout;
extern cvar_t *sys_nostdout;
cvar_t sys_extrasleep = {"sys_extrasleep","0"};
//cvar_t sys_extrasleep = {"sys_extrasleep","0"};
cvar_t *sys_extrasleep;
qboolean stdin_ready;
/*
@ -149,8 +150,13 @@ is marked
*/
void Sys_Init (void)
{
Cvar_RegisterVariable (&sys_nostdout);
Cvar_RegisterVariable (&sys_extrasleep);
/* Note, variables declared in common/ and registered in qw_server/ are
evil */
// Cvar_RegisterVariable (&sys_nostdout);
sys_nostdout = Cvar_Get ("sys_nostdout","0",0,"None");
// Cvar_RegisterVariable (&sys_extrasleep);
sys_extrasleep = Cvar_Get ("sys_extrasleep","0",0,"None");
}
/*
@ -216,8 +222,8 @@ int main(int argc, char *argv[])
SV_Frame (time);
// extrasleep is just a way to generate a fucked up connection on purpose
if (sys_extrasleep.value)
usleep (sys_extrasleep.value);
if (sys_extrasleep->value)
usleep (sys_extrasleep->value);
}
exit(0);
}

6
qw_server/sys_win.c
View file

@ -33,7 +33,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include <client.h>
extern cvar_t sys_nostdout;
extern cvar_t *sys_nostdout;
/*
================
@ -122,7 +122,9 @@ is marked
*/
void Sys_Init (void)
{
Cvar_RegisterVariable (&sys_nostdout);
// Cvar_RegisterVariable (&sys_nostdout);
/* Fix this sometime. */
sys_nostdout = Cvar_Get ("sys_nostdout","0");
}
/*

6
uquake/cl_parse.c
View file

@ -528,7 +528,7 @@ void CL_ParseStaticSound (void)
}
#define SHOWNET(x) if(cl_shownet.value==2)Con_Printf ("%3i:%s\n", msg_readcount-1, x);
#define SHOWNET(x) if(cl_shownet->value==2)Con_Printf ("%3i:%s\n", msg_readcount-1, x);
/*
=====================
@ -544,9 +544,9 @@ void CL_ParseServerMessage (void)
//
// if recording demos, copy the message out
//
if (cl_shownet.value == 1)
if (cl_shownet->value == 1)
Con_Printf ("%i ",net_message.cursize);
else if (cl_shownet.value == 2)
else if (cl_shownet->value == 2)
Con_Printf ("------------------\n");
cl.onground = false; // unless the server says otherwise

6
uquake/cl_pred.c
View file

@ -28,8 +28,10 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "console.h"
#include "mathlib.h"
cvar_t cl_nopred = {"cl_nopred","0"};
cvar_t cl_pushlatency = {"pushlatency","-999"};
//cvar_t cl_nopred = {"cl_nopred","0"};
cvar_t *cl_nopred;
//cvar_t cl_pushlatency = {"pushlatency","-999"};
cvar_t *cl_pushlatency;
extern frame_t *view_frame;

4
uquake/d_edge.c
View file

@ -186,7 +186,7 @@ void D_DrawSurfaces (void)
VectorCopy (transformed_modelorg, world_transformed_modelorg);
// TODO: could preset a lot of this at mode set time
if (r_drawflat.value)
if (r_drawflat->value)
{
for (s = &surfaces[1] ; s<surface_p ; s++)
{
@ -232,7 +232,7 @@ void D_DrawSurfaces (void)
d_zistepv = 0;
d_ziorigin = -0.9;
D_DrawSolidSurface (s, (int)r_clearcolor.value & 0xFF);
D_DrawSolidSurface (s, (int)r_clearcolor->value & 0xFF);
D_DrawZSpans (s->spans);
}
else if (s->flags & SURF_DRAWTURB)

34
uquake/host_cmd.c
View file

@ -36,10 +36,10 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include <world.h>
#include <phys.h>
extern cvar_t pausable;
extern cvar_t *pausable;
/* PHS 02/01/2000 */
extern cvar_t sv_filter;
extern cvar_t *sv_filter;
int current_skill;
@ -672,12 +672,12 @@ void Host_Loadgame_f (void)
Qgets(f,buf,sizeof(buf));
sscanf (buf, "%f\n", &tfloat);
current_skill = (int)(tfloat + 0.1);
Cvar_SetValue ("skill", (float)current_skill);
skill->value = (float)current_skill;
#ifdef QUAKE2
Cvar_SetValue ("deathmatch", 0);
Cvar_SetValue ("coop", 0);
Cvar_SetValue ("teamplay", 0);
deathmatch->value = 0;
coop->value = 0;
teamplay->value = 0;
#endif
Qgets(f,buf,sizeof(buf));
@ -795,7 +795,7 @@ void SaveGamestate()
fprintf (f, "%s\n", comment);
// for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
// fprintf (f, "%f\n", svs.clients->spawn_parms[i]);
fprintf (f, "%f\n", skill.value);
fprintf (f, "%f\n", skill->value);
fprintf (f, "%s\n", sv.name);
fprintf (f, "%f\n", sv.time);
@ -862,7 +862,7 @@ int LoadGamestate(char *level, char *startspot)
// }
Qgets(f,buf,sizeof(buf));
sscanf (buf, "%f\n", &sk);
Cvar_SetValue ("skill", sk);
skill->value = sk;
Qgets(f,buf,sizeof(buf));
sscanf (buf, "%s\n",mapname);
@ -988,7 +988,7 @@ void Host_Name_f (void)
if (Cmd_Argc () == 1)
{
Con_Printf ("\"name\" is \"%s\"\n", cl_name.string);
Con_Printf ("\"name\" is \"%s\"\n", cl_name->string);
return;
}
if (Cmd_Argc () == 2)
@ -999,7 +999,7 @@ void Host_Name_f (void)
if (cmd_source == src_command)
{
if (Q_strcmp(cl_name.string, newName) == 0)
if (Q_strcmp(cl_name->string, newName) == 0)
return;
Cvar_Set ("_cl_name", newName);
if (cls.state >= ca_connected)
@ -1011,7 +1011,7 @@ void Host_Name_f (void)
/* If cvar sv_filter is 1 */
/* Check for \n & \r in names and remove, replace with '-' */
if(sv_filter.value == 1)
if(sv_filter->value == 1)
for(Idx=0;Idx<strlen(newName);Idx++)
if((newName[Idx]=='\r') || (newName[Idx]=='\n'))
newName[Idx]='-';
@ -1077,7 +1077,7 @@ void Host_Say(qboolean teamonly)
if (!fromServer)
snprintf(text, sizeof(text), "%c%s: ", 1, save->name);
else
snprintf(text, sizeof(text), "%c<%s> ", 1, hostname.string);
snprintf(text, sizeof(text), "%c<%s> ", 1, hostname->string);
j = sizeof(text) - 2 - Q_strlen(text); // -2 for /n and null terminator
if (Q_strlen(p) > j)
@ -1090,7 +1090,7 @@ void Host_Say(qboolean teamonly)
{
if (!client || !client->active || !client->spawned)
continue;
if (teamplay.value && teamonly && client->edict->v.team != save->edict->v.team)
if (teamplay->value && teamonly && client->edict->v.team != save->edict->v.team)
continue;
host_client = client;
SV_ClientPrintf("%s", text);
@ -1177,7 +1177,7 @@ void Host_Color_f(void)
if (Cmd_Argc() == 1)
{
Con_Printf ("\"color\" is \"%i %i\"\n", ((int)cl_color.value) >> 4, ((int)cl_color.value) & 0x0f);
Con_Printf ("\"color\" is \"%i %i\"\n", ((int)cl_color->value) >> 4, ((int)cl_color->value) & 0x0f);
Con_Printf ("color <0-13> [0-13]\n");
return;
}
@ -1201,7 +1201,7 @@ void Host_Color_f(void)
if (cmd_source == src_command)
{
Cvar_SetValue ("_cl_color", playercolor);
cl_color->value = playercolor;
if (cls.state >= ca_connected)
Cmd_ForwardToServer ();
return;
@ -1254,7 +1254,7 @@ void Host_Pause_f (void)
Cmd_ForwardToServer ();
return;
}
if (!pausable.value)
if (!pausable->value)
SV_ClientPrintf ("Pause not allowed.\n");
else
{
@ -1501,7 +1501,7 @@ void Host_Kick_f (void)
if (cls.state == ca_dedicated)
who = "Console";
else
who = cl_name.string;
who = cl_name->string;
else
who = save->name;

165
uquake/menu.c
View file

@ -739,10 +739,10 @@ void M_Menu_Setup_f (void)
key_dest = key_menu;
m_state = m_setup;
m_entersound = true;
Q_strcpy(setup_myname, cl_name.string);
Q_strcpy(setup_hostname, hostname.string);
setup_top = setup_oldtop = ((int)cl_color.value) >> 4;
setup_bottom = setup_oldbottom = ((int)cl_color.value) & 15;
Q_strcpy(setup_myname, cl_name->string);
Q_strcpy(setup_hostname, hostname->string);
setup_top = setup_oldtop = ((int)cl_color->value) >> 4;
setup_bottom = setup_oldbottom = ((int)cl_color->value) & 15;
}
@ -841,9 +841,9 @@ forward:
goto forward;
// setup_cursor == 4 (OK)
if (Q_strcmp(cl_name.string, setup_myname) != 0)
if (Q_strcmp(cl_name->string, setup_myname) != 0)
Cbuf_AddText ( va ("name \"%s\"\n", setup_myname) );
if (Q_strcmp(hostname.string, setup_hostname) != 0)
if (Q_strcmp(hostname->string, setup_hostname) != 0)
Cvar_Set("hostname", setup_hostname);
if (setup_top != setup_oldtop || setup_bottom != setup_oldbottom)
Cbuf_AddText( va ("color %i %i\n", setup_top, setup_bottom) );
@ -1118,73 +1118,68 @@ void M_AdjustSliders (int dir)
switch (options_cursor)
{
case 3: // screen size
scr_viewsize.value += dir * 10;
if (scr_viewsize.value < 30)
scr_viewsize.value = 30;
if (scr_viewsize.value > 120)
scr_viewsize.value = 120;
Cvar_SetValue ("viewsize", scr_viewsize.value);
scr_viewsize->value += dir * 10;
if (scr_viewsize->value < 30)
scr_viewsize->value = 30;
if (scr_viewsize->value > 120)
scr_viewsize->value = 120;
break;
case 4: // gamma
v_gamma.value -= dir * 0.05;
if (v_gamma.value < 0.5)
v_gamma.value = 0.5;
if (v_gamma.value > 1)
v_gamma.value = 1;
Cvar_SetValue ("gamma", v_gamma.value);
v_gamma->value -= dir * 0.05;
if (v_gamma->value < 0.5)
v_gamma->value = 0.5;
if (v_gamma->value > 1)
v_gamma->value = 1;
break;
case 5: // mouse speed
sensitivity.value += dir * 0.5;
if (sensitivity.value < 1)
sensitivity.value = 1;
if (sensitivity.value > 11)
sensitivity.value = 11;
Cvar_SetValue ("sensitivity", sensitivity.value);
sensitivity->value += dir * 0.5;
if (sensitivity->value < 1)
sensitivity->value = 1;
if (sensitivity->value > 11)
sensitivity->value = 11;
break;
case 6: // music volume
#ifdef _WIN32
bgmvolume.value += dir * 1.0;
bgmvolume->value += dir * 1.0;
#else
bgmvolume.value += dir * 0.1;
bgmvolume->value += dir * 0.1;
#endif
if (bgmvolume.value < 0)
bgmvolume.value = 0;
if (bgmvolume.value > 1)
bgmvolume.value = 1;
Cvar_SetValue ("bgmvolume", bgmvolume.value);
if (bgmvolume->value < 0)
bgmvolume->value = 0;
if (bgmvolume->value > 1)
bgmvolume->value = 1;
break;
case 7: // sfx volume
volume.value += dir * 0.1;
if (volume.value < 0)
volume.value = 0;
if (volume.value > 1)
volume.value = 1;
Cvar_SetValue ("volume", volume.value);
volume->value += dir * 0.1;
if (volume->value < 0)
volume->value = 0;
if (volume->value > 1)
volume->value = 1;
break;
case 8: // allways run
if (cl_forwardspeed.value > 200)
if (cl_forwardspeed->value > 200)
{
Cvar_SetValue ("cl_forwardspeed", 200);
Cvar_SetValue ("cl_backspeed", 200);
cl_forwardspeed->value = 200;
cl_backspeed->value = 200;
}
else
{
Cvar_SetValue ("cl_forwardspeed", 400);
Cvar_SetValue ("cl_backspeed", 400);
cl_forwardspeed->value = 400;
cl_backspeed->value = 400;
}
break;
case 9: // invert mouse
Cvar_SetValue ("m_pitch", -m_pitch.value);
m_pitch->value = -m_pitch->value;
break;
case 10: // lookspring
Cvar_SetValue ("lookspring", !lookspring.value);
lookspring->value = !lookspring->value;
break;
case 11: // lookstrafe
Cvar_SetValue ("lookstrafe", !lookstrafe.value);
lookstrafe->value = !lookstrafe->value;
break;
default:
@ -1238,37 +1233,37 @@ void M_Options_Draw (void)
M_Print (16, options_draw_cursor+=8, " Reset to defaults");
M_Print (16, options_draw_cursor+=8, " Screen size");
r = (scr_viewsize.value - 30) / (120 - 30);
r = (scr_viewsize->value - 30) / (120 - 30);
M_DrawSlider (220, options_draw_cursor, r);
M_Print (16, options_draw_cursor+=8, " Brightness");
r = (1.0 - v_gamma.value) / 0.5;
r = (1.0 - v_gamma->value) / 0.5;
M_DrawSlider (220, options_draw_cursor, r);
M_Print (16, options_draw_cursor+=8, " Mouse Speed");
r = (sensitivity.value - 1)/10;
r = (sensitivity->value - 1)/10;
M_DrawSlider (220, 72, r);
M_Print (16, options_draw_cursor+=8, " CD Music Volume");
r = bgmvolume.value;
r = bgmvolume->value;
M_DrawSlider (220, options_draw_cursor, r);
M_Print (16, options_draw_cursor+=8, " Sound Volume");
r = volume.value;
r = volume->value;
M_DrawSlider (220, options_draw_cursor, r);
M_Print (16, options_draw_cursor+=8, " Always Run");
M_DrawCheckbox (220, options_draw_cursor, cl_forwardspeed.value
M_DrawCheckbox (220, options_draw_cursor, cl_forwardspeed->value
> 200);
M_Print (16, options_draw_cursor+=8, " Invert Mouse");
M_DrawCheckbox (220, options_draw_cursor, m_pitch.value < 0);
M_DrawCheckbox (220, options_draw_cursor, m_pitch->value < 0);
M_Print (16, options_draw_cursor+=8, " Lookspring");
M_DrawCheckbox (220, options_draw_cursor, lookspring.value);
M_DrawCheckbox (220, options_draw_cursor, lookspring->value);
M_Print (16, options_draw_cursor+=8, " Lookstrafe");
M_DrawCheckbox (220, options_draw_cursor, lookstrafe.value);
M_DrawCheckbox (220, options_draw_cursor, lookstrafe->value);
//VID_ExtraOptionDraw(options_draw_cursor);
options_draw_cursor+=VID_options_items*8;
@ -2656,7 +2651,7 @@ void M_GameOptions_Draw (void)
M_Print (160, 56, va("%i", maxplayers) );
M_Print (0, 64, " Game Type");
if (coop.value)
if (coop->value)
M_Print (160, 64, "Cooperative");
else
M_Print (160, 64, "Deathmatch");
@ -2666,7 +2661,7 @@ void M_GameOptions_Draw (void)
{
char *msg;
switch((int)teamplay.value)
switch((int)teamplay->value)
{
case 1: msg = "No Friendly Fire"; break;
case 2: msg = "Friendly Fire"; break;
@ -2682,7 +2677,7 @@ void M_GameOptions_Draw (void)
{
char *msg;
switch((int)teamplay.value)
switch((int)teamplay->value)
{
case 1: msg = "No Friendly Fire"; break;
case 2: msg = "Friendly Fire"; break;
@ -2692,26 +2687,26 @@ void M_GameOptions_Draw (void)
}
M_Print (0, 80, " Skill");
if (skill.value == 0)
if (skill->value == 0)
M_Print (160, 80, "Easy difficulty");
else if (skill.value == 1)
else if (skill->value == 1)
M_Print (160, 80, "Normal difficulty");
else if (skill.value == 2)
else if (skill->value == 2)
M_Print (160, 80, "Hard difficulty");
else
M_Print (160, 80, "Nightmare difficulty");
M_Print (0, 88, " Frag Limit");
if (fraglimit.value == 0)
if (fraglimit->value == 0)
M_Print (160, 88, "none");
else
M_Print (160, 88, va("%i frags", (int)fraglimit.value));
M_Print (160, 88, va("%i frags", (int)fraglimit->value));
M_Print (0, 96, " Time Limit");
if (timelimit.value == 0)
if (timelimit->value == 0)
M_Print (160, 96, "none");
else
M_Print (160, 96, va("%i minutes", (int)timelimit.value));
M_Print (160, 96, va("%i minutes", (int)timelimit->value));
M_Print (0, 112, " Episode");
//MED 01/06/97 added hipnotic episodes
@ -2784,7 +2779,7 @@ void M_NetStart_Change (int dir)
break;
case 2:
Cvar_SetValue ("coop", coop.value ? 0 : 1);
coop->value = (coop->value ? 0 : 1);
break;
case 3:
@ -2793,35 +2788,35 @@ void M_NetStart_Change (int dir)
else
count = 2;
Cvar_SetValue ("teamplay", teamplay.value + dir);
if (teamplay.value > count)
Cvar_SetValue ("teamplay", 0);
else if (teamplay.value < 0)
Cvar_SetValue ("teamplay", count);
teamplay->value = teamplay->value + dir;
if (teamplay->value > count)
teamplay->value = 0;
else if (teamplay->value < 0)
teamplay->value = count;
break;
case 4:
Cvar_SetValue ("skill", skill.value + dir);
if (skill.value > 3)
Cvar_SetValue ("skill", 0);
if (skill.value < 0)
Cvar_SetValue ("skill", 3);
skill->value = skill->value + dir;
if (skill->value > 3)
skill->value = 0;
if (skill->value < 0)
skill->value = 3;
break;
case 5:
Cvar_SetValue ("fraglimit", fraglimit.value + dir*10);
if (fraglimit.value > 100)
Cvar_SetValue ("fraglimit", 0);
if (fraglimit.value < 0)
Cvar_SetValue ("fraglimit", 100);
fraglimit->value = fraglimit->value + dir*10;
if (fraglimit->value > 100)
fraglimit->value = 0;
if (fraglimit->value < 0)
fraglimit->value = 100;
break;
case 6:
Cvar_SetValue ("timelimit", timelimit.value + dir*5);
if (timelimit.value > 60)
Cvar_SetValue ("timelimit", 0);
if (timelimit.value < 0)
Cvar_SetValue ("timelimit", 60);
timelimit->value = timelimit->value + dir*5;
if (timelimit->value > 60)
timelimit->value = 0;
if (timelimit->value < 0)
timelimit->value = 60;
break;
case 7:

16
uquake/net_comx.c
View file

@ -44,14 +44,14 @@ typedef struct
#define ENQUEUE(q,b) (q.data[q.head] = b, q.head = (q.head + 1) & QUEUEMASK)
#define DEQUEUE(q,b) (b = q.data[q.tail], q.tail = (q.tail + 1) & QUEUEMASK)
extern cvar_t config_com_port;
extern cvar_t config_com_irq;
extern cvar_t config_com_baud;
extern cvar_t config_com_modem;
extern cvar_t config_modem_dialtype;
extern cvar_t config_modem_clear;
extern cvar_t config_modem_init;
extern cvar_t config_modem_hangup;
extern cvar_t *config_com_port;
extern cvar_t *config_com_irq;
extern cvar_t *config_com_baud;
extern cvar_t *config_com_modem;
extern cvar_t *config_modem_dialtype;
extern cvar_t *config_modem_clear;
extern cvar_t *config_modem_init;
extern cvar_t *config_modem_hangup;
extern int m_return_state;
extern int m_state;

4
uquake/net_dgrm.c
View file

@ -889,7 +889,7 @@ static qsocket_t *_Datagram_CheckNewConnections (void)
MSG_WriteByte(&net_message, CCREP_SERVER_INFO);
dfunc.GetSocketAddr(acceptsock, &newaddr);
MSG_WriteString(&net_message, dfunc.AddrToString(&newaddr));
MSG_WriteString(&net_message, hostname.string);
MSG_WriteString(&net_message, hostname->string);
MSG_WriteString(&net_message, sv.name);
MSG_WriteByte(&net_message, net_activeconnections);
MSG_WriteByte(&net_message, svs.maxclients);
@ -958,7 +958,7 @@ static qsocket_t *_Datagram_CheckNewConnections (void)
// search for the next server cvar
while (var)
{
if (var->type&CVAR_NOTIFY)
if (var->flags&CVAR_NOTIFY)
break;
var = var->next;
}

Some files were not shown because too many files have changed in this diff Show more