// we need to declare some mouse variables here, because the menu system
// references them even when on a unix system.
-cvar_t csqc_progname = {0, "csqc_progname","csprogs.dat","name of csprogs.dat file to load"}; //[515]: csqc crc check and right csprogs name according to progs.dat
+cvar_t csqc_progname = {0, "csqc_progname","csprogs.dat","name of csprogs.dat file to load"};
cvar_t csqc_progcrc = {CVAR_READONLY, "csqc_progcrc","-1","CRC of csprogs.dat file to load (-1 is none), only used during level changes and then reset to -1"};
cvar_t csqc_progsize = {CVAR_READONLY, "csqc_progsize","-1","file size of csprogs.dat file to load (-1 is none), only used during level changes and then reset to -1"};
cvar_t freelook = {CVAR_SAVE, "freelook", "1","mouse controls pitch instead of forward/back"};
-#ifdef AUTODEMO_BROKEN
-cvar_t cl_autodemo = {0, "cl_autodemo", "0", "records every game played, using the date/time and map name to name the demo file" };
-cvar_t cl_autodemo_nameformat = {0, "cl_autodemo_nameformat", "%Y-%m-%d_%H-%M", "The format of the cl_autodemo filename, followed by the map name" };
-#endif
+cvar_t cl_autodemo = {CVAR_SAVE, "cl_autodemo", "0", "records every game played, using the date/time and map name to name the demo file" };
+cvar_t cl_autodemo_nameformat = {CVAR_SAVE, "cl_autodemo_nameformat", "autodemos/%Y-%m-%d_%H-%M", "The format of the cl_autodemo filename, followed by the map name" };
cvar_t r_draweffects = {0, "r_draweffects", "1","renders temporary sprite effects"};
cvar_t cl_beams_polygons = {CVAR_SAVE, "cl_beams_polygons", "1","use beam polygons instead of models"};
cvar_t cl_beams_quakepositionhack = {CVAR_SAVE, "cl_beams_quakepositionhack", "1", "makes your lightning gun appear to fire from your waist (as in Quake and QuakeWorld)"};
-cvar_t cl_beams_instantaimhack = {CVAR_SAVE, "cl_beams_instantaimhack", "1", "makes your lightning gun aiming update instantly"};
+cvar_t cl_beams_instantaimhack = {CVAR_SAVE, "cl_beams_instantaimhack", "0", "makes your lightning gun aiming update instantly"};
cvar_t cl_beams_lightatend = {CVAR_SAVE, "cl_beams_lightatend", "0", "make a light at the end of the beam"};
cvar_t cl_noplayershadow = {CVAR_SAVE, "cl_noplayershadow", "0","hide player shadow"};
+cvar_t cl_dlights_decayradius = {CVAR_SAVE, "cl_dlights_decayradius", "1", "reduces size of light flashes over time"};
+cvar_t cl_dlights_decaybrightness = {CVAR_SAVE, "cl_dlights_decaybrightness", "1", "reduces brightness of light flashes over time"};
+
cvar_t qport = {0, "qport", "0", "identification key for playing on qw servers (allows you to maintain a connection to a quakeworld server even if your port changes)"};
cvar_t cl_prydoncursor = {0, "cl_prydoncursor", "0", "enables a mouse pointer which is able to click on entities in the world, useful for point and click mods, see PRYDON_CLIENTCURSOR extension in dpextensions.qc"};
cvar_t cl_deathnoviewmodel = {0, "cl_deathnoviewmodel", "1", "hides gun model when dead"};
+cvar_t cl_locs_enable = {CVAR_SAVE, "locs_enable", "1", "enables replacement of certain % codes in chat messages: %l (location), %d (last death location), %h (health), %a (armor), %x (rockets), %c (cells), %r (rocket launcher status), %p (powerup status), %w (weapon status), %t (current time in level)"};
+cvar_t cl_locs_show = {0, "locs_show", "0", "shows defined locations for editing purposes"};
+
client_static_t cls;
client_state_t cl;
// reset the view zoom interpolation
cl.mviewzoom[0] = cl.mviewzoom[1] = 1;
+ // enable rendering of the world and such
+ cl.csqc_vidvars.drawworld = true;
+ cl.csqc_vidvars.drawenginesbar = true;
+ cl.csqc_vidvars.drawcrosshair = true;
+
+ // set up the float version of the stats array for easier access to float stats
+ cl.statsf = (float *)cl.stats;
+
cl.num_entities = 0;
cl.num_static_entities = 0;
cl.num_temp_entities = 0;
if (cls.state == ca_dedicated)
return;
+ Curl_Clear_forthismap();
+
Con_DPrintf("CL_Disconnect\n");
CL_VM_ShutDown();
Con_DPrint("Sending clc_disconnect\n");
MSG_WriteByte(&buf, clc_disconnect);
}
- NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol);
- NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol);
- NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol);
+ NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol, 10000, false);
+ NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol, 10000, false);
+ NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol, 10000, false);
NetConn_Close(cls.netcon);
cls.netcon = NULL;
}
cls.demonum = -1;
// stop demo loop in case this fails
- CL_Disconnect();
+ if (cls.demoplayback)
+ CL_StopPlayback();
// if downloads are running, cancel their finishing action
Curl_Clear_forthismap();
modelname = ent->render.model->name;
else
modelname = "--no model--";
- Con_Printf("%3i: %-25s:%4i (%5i %5i %5i) [%3i %3i %3i] %4.2f %5.3f\n", i, modelname, ent->render.frame, (int) ent->state_current.origin[0], (int) ent->state_current.origin[1], (int) ent->state_current.origin[2], (int) ent->state_current.angles[0] % 360, (int) ent->state_current.angles[1] % 360, (int) ent->state_current.angles[2] % 360, ent->render.scale, ent->render.alpha);
+ Con_Printf("%3i: %-25s:%4i (%5i %5i %5i) [%3i %3i %3i] %4.2f %5.3f\n", i, modelname, ent->render.frame2, (int) ent->state_current.origin[0], (int) ent->state_current.origin[1], (int) ent->state_current.origin[2], (int) ent->state_current.angles[0] % 360, (int) ent->state_current.angles[1] % 360, (int) ent->state_current.angles[2] % 360, ent->render.scale, ent->render.alpha);
+ }
+}
+
+/*
+===============
+CL_ModelIndexList_f
+
+List all models in the client modelindex
+===============
+*/
+static void CL_ModelIndexList_f(void)
+{
+ int nModelIndexCnt = 1;
+
+ while(cl.model_precache[nModelIndexCnt] && nModelIndexCnt != MAX_MODELS)
+ { // Valid Model
+ Con_Printf("%i : %s\n", nModelIndexCnt, cl.model_precache[nModelIndexCnt]->name);
+ nModelIndexCnt++;
}
}
{
float f;
- if (cl_nettimesyncmode.integer == 3)
+ if (cl_nettimesyncboundmode.integer == 1)
cl.time = bound(cl.mtime[1], cl.time, cl.mtime[0]);
// LordHavoc: lerp in listen games as the server is being capped below the client (usually)
Matrix4x4_OriginFromMatrix(&dl->matrix, dl->origin);
CL_FindNonSolidLocation(dl->origin, dl->origin, 6);
Matrix4x4_SetOrigin(&dl->matrix, dl->origin[0], dl->origin[1], dl->origin[2]);
- Matrix4x4_Scale(&dl->matrix, radius, 1);
dl->radius = radius;
dl->color[0] = red;
dl->color[1] = green;
dl->intensity -= time * dl->decay;
if (cl.time < dl->die && dl->intensity > 0)
{
- //dl->radius = dl->initialradius * dl->intensity;
- VectorScale(dl->initialcolor, dl->intensity, dl->color);
+ if (cl_dlights_decayradius.integer)
+ dl->radius = dl->initialradius * dl->intensity;
+ else
+ dl->radius = dl->initialradius;
+ if (cl_dlights_decaybrightness.integer)
+ VectorScale(dl->initialcolor, dl->intensity, dl->color);
+ else
+ VectorCopy(dl->initialcolor, dl->color);
cl.num_dlights = i + 1;
}
else
int i, j, k, l;
dlight_t *dl;
float frac, f;
+ matrix4x4_t tempmatrix;
if (r_dynamic.integer)
+ {
for (i = 0, dl = cl.dlights;i < cl.num_dlights && r_refdef.numlights < MAX_DLIGHTS;i++, dl++)
+ {
if (dl->radius)
- R_RTLight_Update(&r_refdef.lights[r_refdef.numlights++], false, &dl->matrix, dl->color, dl->style, dl->cubemapname, dl->shadow, dl->corona, dl->coronasizescale, dl->ambientscale, dl->diffusescale, dl->specularscale, dl->flags);
+ {
+ tempmatrix = dl->matrix;
+ Matrix4x4_Scale(&tempmatrix, dl->radius, 1);
+ R_RTLight_Update(&r_refdef.lights[r_refdef.numlights++], false, &tempmatrix, dl->color, dl->style, dl->cubemapname, dl->shadow, dl->corona, dl->coronasizescale, dl->ambientscale, dl->diffusescale, dl->specularscale, dl->flags);
+ }
+ }
+ }
// light animations
// 'm' is normal light, 'a' is no light, 'z' is double bright
extern void V_CalcRefdef(void);
// note this is a recursive function, recursionlimit should be 32 or so on the initial call
-void CL_UpdateNetworkEntity(entity_t *e, int recursionlimit)
+void CL_UpdateNetworkEntity(entity_t *e, int recursionlimit, qboolean interpolate)
{
const matrix4x4_t *matrix;
matrix4x4_t blendmatrix, tempmatrix, matrix2;
e->render.flags = e->state_current.flags;
e->render.effects = e->state_current.effects;
VectorScale(e->state_current.colormod, (1.0f / 32.0f), e->render.colormod);
+ e->render.entitynumber = e - cl.entities;
if (e->state_current.flags & RENDER_COLORMAPPED)
{
int cb;
if (!t->state_current.active)
return;
// update the parent first
- CL_UpdateNetworkEntity(t, recursionlimit - 1);
+ CL_UpdateNetworkEntity(t, recursionlimit - 1, interpolate);
// make relative to the entity
matrix = &t->render.matrix;
// some properties of the tag entity carry over
else if (e->render.flags & RENDER_VIEWMODEL)
{
// view-relative entity (guns and such)
- matrix = &viewmodelmatrix;
+ if (e->render.effects & EF_NOGUNBOB)
+ matrix = &r_view.matrix; // really attached to view
+ else
+ matrix = &viewmodelmatrix; // attached to gun bob matrix
}
else
{
// movement lerp
// if it's the predicted player entity, update according to client movement
- if (e == cl.entities + cl.playerentity && cl.movement_predicted)
+ // but don't lerp if going through a teleporter as it causes a bad lerp
+ // also don't use the predicted location if fixangle was set on both of
+ // the most recent server messages, as that cause means you are spectating
+ // someone or watching a cutscene of some sort
+ if (cl_nolerp.integer || cls.timedemo)
+ interpolate = false;
+ if (e == cl.entities + cl.playerentity && cl.movement_predicted && (!cl.fixangle[1] || !cl.fixangle[0]))
{
lerp = (cl.time - cl.movement_time[2]) / (cl.movement_time[0] - cl.movement_time[1]);
lerp = bound(0, lerp, 1);
- if (cl_nolerp.integer)
+ if (!interpolate)
lerp = 1;
VectorLerp(cl.movement_oldorigin, lerp, cl.movement_origin, origin);
VectorSet(angles, 0, cl.viewangles[1], 0);
}
- else if (e->persistent.lerpdeltatime > 0 && (lerp = (cl.time - e->persistent.lerpstarttime) / e->persistent.lerpdeltatime) < 1)
+ else if (interpolate && e->persistent.lerpdeltatime > 0 && (lerp = (cl.time - e->persistent.lerpstarttime) / e->persistent.lerpdeltatime) < 1)
{
// interpolate the origin and angles
lerp = max(0, lerp);
e->render.model = cl.model_precache[e->state_current.modelindex];
if (e->render.model)
{
+ // models can set flags such as EF_ROCKET
+ // this 0xFF800000 mask is EF_NOMODELFLAGS plus all the higher EF_ flags such as EF_ROCKET
+ if (!(e->render.effects & 0xFF800000))
+ e->render.effects |= e->render.model->effects;
// if model is alias or this is a tenebrae-like dlight, reverse pitch direction
if (e->render.model->type == mod_alias)
angles[0] = -angles[0];
- if ((e->render.model->flags & EF_ROTATE) && (!e->state_current.tagentity && !(e->render.flags & RENDER_VIEWMODEL)))
- {
- angles[1] = ANGLEMOD(100*cl.time);
- if (cl_itembobheight.value)
- origin[2] += (cos(cl.time * cl_itembobspeed.value * (2.0 * M_PI)) + 1.0) * 0.5 * cl_itembobheight.value;
- }
- // transfer certain model flags to effects
- e->render.effects |= e->render.model->flags2 & (EF_FULLBRIGHT | EF_ADDITIVE);
if ((e->render.effects & EF_SELECTABLE) && cl.cmd.cursor_entitynumber == e->state_current.number)
VectorScale(e->render.colormod, 2, e->render.colormod);
}
else if (e->state_current.lightpflags & PFLAGS_FULLDYNAMIC)
angles[0] = -angles[0];
+ if ((e->render.effects & EF_ROTATE) && !(e->render.flags & RENDER_VIEWMODEL))
+ {
+ angles[1] = ANGLEMOD(100*cl.time);
+ if (cl_itembobheight.value)
+ origin[2] += (cos(cl.time * cl_itembobspeed.value * (2.0 * M_PI)) + 1.0) * 0.5 * cl_itembobheight.value;
+ }
+
// animation lerp
if (e->render.frame2 == e->state_current.frame)
{
// begin a new frame lerp
e->render.frame1 = e->render.frame2;
e->render.frame1time = e->render.frame2time;
- e->render.frame = e->render.frame2 = e->state_current.frame;
+ e->render.frame2 = e->state_current.frame;
e->render.frame2time = cl.time;
e->render.framelerp = 0;
}
// player model is only shown with chase_active on
if (e->state_current.number == cl.viewentity)
e->render.flags |= RENDER_EXTERIORMODEL;
- // transparent stuff can't be lit during the opaque stage
- if (e->render.effects & (EF_ADDITIVE | EF_NODEPTHTEST) || e->render.alpha < 1)
- e->render.flags |= RENDER_TRANSPARENT;
- // double sided rendering mode causes backfaces to be visible
- // (mostly useful on transparent stuff)
- if (e->render.effects & EF_DOUBLESIDED)
- e->render.flags |= RENDER_NOCULLFACE;
// either fullbright or lit
if (!(e->render.effects & EF_FULLBRIGHT) && !r_fullbright.integer)
e->render.flags |= RENDER_LIGHT;
// hide player shadow during intermission or nehahra movie
- if (!(e->render.effects & EF_NOSHADOW)
- && !(e->render.flags & (RENDER_VIEWMODEL | RENDER_TRANSPARENT))
+ if (!(e->render.effects & (EF_NOSHADOW | EF_ADDITIVE | EF_NODEPTHTEST))
+ && (e->render.alpha >= 1)
+ && !(e->render.flags & RENDER_VIEWMODEL)
&& (!(e->render.flags & RENDER_EXTERIORMODEL) || (!cl.intermission && cls.protocol != PROTOCOL_NEHAHRAMOVIE && !cl_noplayershadow.integer)))
e->render.flags |= RENDER_SHADOW;
+ if (e->render.flags & RENDER_VIEWMODEL)
+ e->render.flags |= RENDER_NOSELFSHADOW;
}
// creates light and trails from an entity
// entity is in the world...
trailtype = EFFECT_NONE;
// LordHavoc: if the entity has no effects, don't check each
- if (e->render.effects & (EF_BRIGHTFIELD | EF_FLAME | EF_STARDUST | EF_FLAG1QW | EF_FLAG2QW))
+ if (e->render.effects & (EF_BRIGHTFIELD | EF_FLAME | EF_STARDUST))
{
if (e->render.effects & EF_BRIGHTFIELD)
{
CL_ParticleTrail(EFFECT_EF_FLAME, bound(0, cl.time - cl.oldtime, 0.1), origin, origin, vec3_origin, vec3_origin, NULL, 0, false, true);
if (e->render.effects & EF_STARDUST)
CL_ParticleTrail(EFFECT_EF_STARDUST, bound(0, cl.time - cl.oldtime, 0.1), origin, origin, vec3_origin, vec3_origin, NULL, 0, false, true);
- if (e->render.effects & (EF_FLAG1QW | EF_FLAG2QW))
- {
- // these are only set on player entities
- CL_AddQWCTFFlagModel(e, (e->render.effects & EF_FLAG2QW) != 0);
- }
+ }
+ if (e->render.internaleffects & (INTEF_FLAG1QW | INTEF_FLAG2QW))
+ {
+ // these are only set on player entities
+ CL_AddQWCTFFlagModel(e, (e->render.internaleffects & INTEF_FLAG2QW) != 0);
}
// muzzleflash fades over time
if (e->persistent.muzzleflash > 0)
e->persistent.muzzleflash -= bound(0, cl.time - cl.oldtime, 0.1) * 20;
- // LordHavoc: if the model has no flags, don't check each
- if (e->render.model && e->render.model->flags && (!e->state_current.tagentity && !(e->render.flags & RENDER_VIEWMODEL)))
+ // LordHavoc: if the entity has no effects, don't check each
+ if (e->render.model && e->render.effects && !(e->render.flags & RENDER_VIEWMODEL))
{
- if (e->render.model->flags & EF_GIB)
+ if (e->render.effects & EF_GIB)
trailtype = EFFECT_TR_BLOOD;
- else if (e->render.model->flags & EF_ZOMGIB)
+ else if (e->render.effects & EF_ZOMGIB)
trailtype = EFFECT_TR_SLIGHTBLOOD;
- else if (e->render.model->flags & EF_TRACER)
+ else if (e->render.effects & EF_TRACER)
trailtype = EFFECT_TR_WIZSPIKE;
- else if (e->render.model->flags & EF_TRACER2)
+ else if (e->render.effects & EF_TRACER2)
trailtype = EFFECT_TR_KNIGHTSPIKE;
- else if (e->render.model->flags & EF_ROCKET)
+ else if (e->render.effects & EF_ROCKET)
trailtype = EFFECT_TR_ROCKET;
- else if (e->render.model->flags & EF_GRENADE)
+ else if (e->render.effects & EF_GRENADE)
{
// LordHavoc: e->render.alpha == -1 is for Nehahra dem compatibility (cigar smoke)
trailtype = e->render.alpha == -1 ? EFFECT_TR_NEHAHRASMOKE : EFFECT_TR_GRENADE;
}
- else if (e->render.model->flags & EF_TRACER3)
+ else if (e->render.effects & EF_TRACER3)
trailtype = EFFECT_TR_VORESPIKE;
}
// do trails
if (e->render.flags & RENDER_GLOWTRAIL)
trailtype = EFFECT_TR_GLOWTRAIL;
- if (trailtype)
+ // check if a trail is allowed (it is not after a teleport for example)
+ if (trailtype && e->persistent.trail_allowed)
{
float len;
vec3_t vel;
VectorScale(vel, len, vel);
CL_ParticleTrail(trailtype, 1, e->persistent.trail_origin, origin, vel, vel, e, e->state_current.glowcolor, false, true);
}
+ // now that the entity has survived one trail update it is allowed to
+ // leave a real trail on later frames
+ e->persistent.trail_allowed = true;
VectorCopy(origin, e->persistent.trail_origin);
}
/*
===============
-CL_UpdateEntities
+CL_UpdateViewEntities
+===============
+*/
+void CL_UpdateViewEntities(void)
+{
+ int i;
+ // update any RENDER_VIEWMODEL entities to use the new view matrix
+ for (i = 1;i < cl.num_entities;i++)
+ {
+ if (cl.entities_active[i])
+ {
+ entity_t *ent = cl.entities + i;
+ if ((ent->render.flags & RENDER_VIEWMODEL) || ent->state_current.tagentity)
+ CL_UpdateNetworkEntity(ent, 32, true);
+ }
+ }
+ // and of course the engine viewmodel needs updating as well
+ CL_UpdateNetworkEntity(&cl.viewent, 32, true);
+}
+
+/*
+===============
+CL_UpdateNetworkCollisionEntities
===============
*/
-void CL_UpdateEntities(void)
+void CL_UpdateNetworkCollisionEntities(void)
{
entity_t *ent;
int i;
- // process network entities
- // first link the player
- CL_UpdateNetworkEntity(cl.entities + cl.viewentity, 32);
+ // start on the entity after the world
+ cl.num_brushmodel_entities = 0;
+ for (i = cl.maxclients + 1;i < cl.num_entities;i++)
+ {
+ if (cl.entities_active[i])
+ {
+ ent = cl.entities + i;
+ if (ent->state_current.active && ent->render.model && ent->render.model->name[0] == '*' && ent->render.model->TraceBox)
+ {
+ // do not interpolate the bmodels for this
+ CL_UpdateNetworkEntity(ent, 32, false);
+ cl.brushmodel_entities[cl.num_brushmodel_entities++] = i;
+ }
+ }
+ }
+}
- // set up the view
- V_CalcRefdef();
+/*
+===============
+CL_UpdateNetworkEntities
+===============
+*/
+void CL_UpdateNetworkEntities(void)
+{
+ entity_t *ent;
+ int i;
// start on the entity after the world
- // skip the player entity because it was already processed
for (i = 1;i < cl.num_entities;i++)
{
if (cl.entities_active[i])
ent = cl.entities + i;
if (ent->state_current.active)
{
- CL_UpdateNetworkEntity(ent, 32);
+ CL_UpdateNetworkEntity(ent, 32, true);
// view models should never create light/trails
if (!(ent->render.flags & RENDER_VIEWMODEL))
CL_UpdateNetworkEntityTrail(ent);
- if (ent->render.model && ent->render.model->name[0] == '*' && ent->render.model->TraceBox)
- cl.brushmodel_entities[cl.num_brushmodel_entities++] = ent->state_current.number;
}
else
cl.entities_active[i] = false;
}
}
+}
+void CL_UpdateViewModel(void)
+{
+ entity_t *ent;
ent = &cl.viewent;
ent->state_previous = ent->state_current;
ent->state_current = defaultstate;
ent->state_current.modelindex = 0;
}
ent->state_current.alpha = cl.entities[cl.viewentity].state_current.alpha;
- ent->state_current.effects = EF_NOSHADOW | (cl.entities[cl.viewentity].state_current.effects & (EF_ADDITIVE | EF_REFLECTIVE | EF_FULLBRIGHT | EF_NODEPTHTEST));
+ ent->state_current.effects = EF_NOSHADOW | (cl.entities[cl.viewentity].state_current.effects & (EF_ADDITIVE | EF_FULLBRIGHT | EF_NODEPTHTEST | EF_NOGUNBOB));
// reset animation interpolation on weaponmodel if model changed
if (ent->state_previous.modelindex != ent->state_current.modelindex)
{
- ent->render.frame = ent->render.frame1 = ent->render.frame2 = ent->state_current.frame;
+ ent->render.frame1 = ent->render.frame2 = ent->state_current.frame;
ent->render.frame1time = ent->render.frame2time = cl.time;
ent->render.framelerp = 1;
}
- CL_UpdateNetworkEntity(ent, 32);
+ CL_UpdateNetworkEntity(ent, 32, true);
}
// note this is a recursive function, but it can never get in a runaway loop (because of the delayedlink flags)
// skip inactive entities and world
if (!e->state_current.active || e == cl.entities)
return;
- if (e->render.flags & RENDER_VIEWMODEL && !e->state_current.tagentity)
- {
- if (!r_drawviewmodel.integer || chase_active.integer || r_refdef.envmap)
- return;
- }
- else
+ if (e->state_current.tagentity)
{
// if the tag entity is currently impossible, skip it
if (e->state_current.tagentity >= cl.num_entities)
R_RTLight_Update(&r_refdef.lights[r_refdef.numlights++], false, &tempmatrix, color, -1, NULL, true, 0, 0.25, 0, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
}
// LordHavoc: if the model has no flags, don't check each
- if (e->render.model && e->render.model->flags && (!e->state_current.tagentity && !(e->render.flags & RENDER_VIEWMODEL)))
+ if (e->render.model && e->render.effects && !(e->render.flags & RENDER_VIEWMODEL))
{
- if (e->render.model->flags & EF_GIB)
+ if (e->render.effects & EF_GIB)
trailtype = EFFECT_TR_BLOOD;
- else if (e->render.model->flags & EF_ZOMGIB)
+ else if (e->render.effects & EF_ZOMGIB)
trailtype = EFFECT_TR_SLIGHTBLOOD;
- else if (e->render.model->flags & EF_TRACER)
+ else if (e->render.effects & EF_TRACER)
trailtype = EFFECT_TR_WIZSPIKE;
- else if (e->render.model->flags & EF_TRACER2)
+ else if (e->render.effects & EF_TRACER2)
trailtype = EFFECT_TR_KNIGHTSPIKE;
- else if (e->render.model->flags & EF_ROCKET)
+ else if (e->render.effects & EF_ROCKET)
trailtype = EFFECT_TR_ROCKET;
- else if (e->render.model->flags & EF_GRENADE)
+ else if (e->render.effects & EF_GRENADE)
{
// LordHavoc: e->render.alpha == -1 is for Nehahra dem compatibility (cigar smoke)
trailtype = e->render.alpha == -1 ? EFFECT_TR_NEHAHRASMOKE : EFFECT_TR_GRENADE;
}
- else if (e->render.model->flags & EF_TRACER3)
+ else if (e->render.effects & EF_TRACER3)
trailtype = EFFECT_TR_VORESPIKE;
}
// LordHavoc: customizable glow
if (trailtype)
CL_ParticleTrail(trailtype, 0, origin, origin, vec3_origin, vec3_origin, NULL, e->state_current.glowcolor, true, false);
+ // don't show viewmodels in certain situations
+ if (e->render.flags & RENDER_VIEWMODEL)
+ if (!r_drawviewmodel.integer || chase_active.integer || r_refdef.envmap)
+ return;
// don't show entities with no modelindex (note: this still shows
// entities which have a modelindex that resolved to a NULL model)
if (e->render.model && !(e->render.effects & EF_NODRAW) && r_refdef.numentities < r_refdef.maxentities)
void CL_RelinkWorld(void)
{
entity_t *ent = &cl.entities[0];
- cl.brushmodel_entities[cl.num_brushmodel_entities++] = 0;
// FIXME: this should be done at load
ent->render.matrix = identitymatrix;
CL_UpdateRenderEntity(&ent->render);
// need to re-fetch the model pointer
e->render.model = cl.model_precache[e->state_baseline.modelindex];
CL_UpdateRenderEntity(&e->render);
- // transparent stuff can't be lit during the opaque stage
- if (e->render.effects & (EF_ADDITIVE | EF_NODEPTHTEST) || e->render.alpha < 1)
- e->render.flags |= RENDER_TRANSPARENT;
// either fullbright or lit
if (!(e->render.effects & EF_FULLBRIGHT) && !r_fullbright.integer)
e->render.flags |= RENDER_LIGHT;
// hide player shadow during intermission or nehahra movie
- if (!(e->render.effects & EF_NOSHADOW) && !(e->render.flags & RENDER_TRANSPARENT))
+ if (!(e->render.effects & (EF_NOSHADOW | EF_ADDITIVE | EF_NODEPTHTEST)) && (e->render.alpha >= 1))
e->render.flags |= RENDER_SHADOW;
VectorSet(e->render.colormod, 1, 1, 1);
R_LerpAnimation(&e->render);
ent->render.model = cl.model_precache[e->modelindex];
else
ent->render.model = cl.csqc_model_precache[-(e->modelindex+1)];
- ent->render.frame = ent->render.frame2;
ent->render.colormap = -1; // no special coloring
ent->render.alpha = 1;
VectorSet(ent->render.colormod, 1, 1, 1);
vec3_t dist, org, start, end;
float d;
entity_t *ent;
- float yaw, pitch;
+ double yaw, pitch;
float forward;
matrix4x4_t tempmatrix;
}
else
{
- yaw = (int) (atan2(dist[1], dist[0]) * 180 / M_PI);
+ yaw = atan2(dist[1], dist[0]) * 180 / M_PI;
if (yaw < 0)
yaw += 360;
forward = sqrt (dist[0]*dist[0] + dist[1]*dist[1]);
- pitch = (int) (atan2(dist[2], forward) * 180 / M_PI);
+ pitch = atan2(dist[2], forward) * 180 / M_PI;
if (pitch < 0)
pitch += 360;
}
/*
===============
-CL_ReadFromServer
+CL_UpdateWorld
-Read all incoming data from the server
+Update client game world for a new frame
===============
*/
-int CL_ReadFromServer(void)
+void CL_UpdateWorld(void)
{
- CL_ReadDemoMessage();
- CL_SendMove();
-
- r_refdef.time = cl.time;
r_refdef.extraupdate = !r_speeds.integer;
r_refdef.numentities = 0;
r_refdef.numlights = 0;
V_DriftPitch();
V_FadeViewFlashs();
- // now update all the network entities and the view matrix
- CL_UpdateEntities();
+ // if prediction is enabled we have to update all the collidable
+ // network entities before the prediction code can be run
+ CL_UpdateNetworkCollisionEntities();
+
+ // now update the player prediction
+ CL_ClientMovement_Replay();
+
+ // update the player entity (which may be predicted)
+ CL_UpdateNetworkEntity(cl.entities + cl.viewentity, 32, true);
+
+ // now update the view (which depends on that player entity)
+ V_CalcRefdef();
+
+ // now update all the network entities and create particle trails
+ // (some entities may depend on the view)
+ CL_UpdateNetworkEntities();
+
+ // update the engine-based viewmodel
+ CL_UpdateViewModel();
CL_RelinkLightFlashes();
CSQC_RelinkAllEntities(ENTMASK_ENGINE | ENTMASK_ENGINEVIEWMODELS);
// move particles
CL_MoveParticles();
R_MoveExplosions();
-
- // update the r_refdef time again because cl.time may have changed in
- // CL_LerpPoint()
- r_refdef.time = cl.time;
}
- return 0;
+ r_refdef.time = cl.time;
}
// LordHavoc: pausedemo command
static void CL_TimeRefresh_f (void)
{
int i;
- float timestart, timedelta, oldangles[3];
+ float timestart, timedelta;
r_refdef.extraupdate = false;
- VectorCopy(cl.viewangles, oldangles);
- VectorClear(cl.viewangles);
timestart = Sys_DoubleTime();
for (i = 0;i < 128;i++)
}
timedelta = Sys_DoubleTime() - timestart;
- VectorCopy(oldangles, cl.viewangles);
Con_Printf("%f seconds (%f fps)\n", timedelta, 128/timedelta);
}
World_PrintAreaStats(&cl.world, "client");
}
+cl_locnode_t *CL_Locs_FindNearest(const vec3_t point)
+{
+ int i;
+ cl_locnode_t *loc;
+ cl_locnode_t *best;
+ vec3_t nearestpoint;
+ vec_t dist, bestdist;
+ best = NULL;
+ bestdist = 0;
+ for (loc = cl.locnodes;loc;loc = loc->next)
+ {
+ for (i = 0;i < 3;i++)
+ nearestpoint[i] = bound(loc->mins[i], point[i], loc->maxs[i]);
+ dist = VectorDistance2(nearestpoint, point);
+ if (bestdist > dist || !best)
+ {
+ bestdist = dist;
+ best = loc;
+ if (bestdist < 1)
+ break;
+ }
+ }
+ return best;
+}
+
+void CL_Locs_FindLocationName(char *buffer, size_t buffersize, vec3_t point)
+{
+ cl_locnode_t *loc;
+ loc = CL_Locs_FindNearest(point);
+ if (loc)
+ strlcpy(buffer, loc->name, buffersize);
+ else
+ dpsnprintf(buffer, buffersize, "LOC=%.0f:%.0f:%.0f", point[0], point[1], point[2]);
+}
+
+void CL_Locs_FreeNode(cl_locnode_t *node)
+{
+ cl_locnode_t **pointer, **next;
+ for (pointer = &cl.locnodes;*pointer;pointer = next)
+ {
+ next = &(*pointer)->next;
+ if (*pointer == node)
+ {
+ *pointer = node->next;
+ Mem_Free(node);
+ }
+ }
+ Con_Printf("CL_Locs_FreeNode: no such node! (%p)\n", node);
+}
+
+void CL_Locs_AddNode(vec3_t mins, vec3_t maxs, const char *name)
+{
+ cl_locnode_t *node, **pointer;
+ int namelen;
+ if (!name)
+ name = "";
+ namelen = strlen(name);
+ node = Mem_Alloc(cls.levelmempool, sizeof(cl_locnode_t) + namelen + 1);
+ VectorSet(node->mins, min(mins[0], maxs[0]), min(mins[1], maxs[1]), min(mins[2], maxs[2]));
+ VectorSet(node->maxs, max(mins[0], maxs[0]), max(mins[1], maxs[1]), max(mins[2], maxs[2]));
+ node->name = (char *)(node + 1);
+ memcpy(node->name, name, namelen);
+ node->name[namelen] = 0;
+ // link it into the tail of the list to preserve the order
+ for (pointer = &cl.locnodes;*pointer;pointer = &(*pointer)->next)
+ ;
+ *pointer = node;
+}
+
+void CL_Locs_Add_f(void)
+{
+ vec3_t mins, maxs;
+ if (Cmd_Argc() != 5 && Cmd_Argc() != 8)
+ {
+ Con_Printf("usage: %s x y z[ x y z] name\n", Cmd_Argv(0));
+ return;
+ }
+ mins[0] = atof(Cmd_Argv(1));
+ mins[1] = atof(Cmd_Argv(2));
+ mins[2] = atof(Cmd_Argv(3));
+ if (Cmd_Argc() == 8)
+ {
+ maxs[0] = atof(Cmd_Argv(4));
+ maxs[1] = atof(Cmd_Argv(5));
+ maxs[2] = atof(Cmd_Argv(6));
+ CL_Locs_AddNode(mins, maxs, Cmd_Argv(7));
+ }
+ else
+ CL_Locs_AddNode(mins, mins, Cmd_Argv(4));
+}
+
+void CL_Locs_RemoveNearest_f(void)
+{
+ cl_locnode_t *loc;
+ loc = CL_Locs_FindNearest(r_view.origin);
+ if (loc)
+ CL_Locs_FreeNode(loc);
+ else
+ Con_Printf("no loc point or box found for your location\n");
+}
+
+void CL_Locs_Clear_f(void)
+{
+ while (cl.locnodes)
+ CL_Locs_FreeNode(cl.locnodes);
+}
+
+void CL_Locs_Save_f(void)
+{
+ cl_locnode_t *loc;
+ qfile_t *outfile;
+ char locfilename[MAX_QPATH];
+ if (!cl.locnodes)
+ {
+ Con_Printf("No loc points/boxes exist!\n");
+ return;
+ }
+ if (cls.state != ca_connected || !cl.worldmodel)
+ {
+ Con_Printf("No level loaded!\n");
+ return;
+ }
+ FS_StripExtension(cl.worldmodel->name, locfilename, sizeof(locfilename));
+ strlcat(locfilename, ".loc", sizeof(locfilename));
+
+ outfile = FS_Open(locfilename, "w", false, false);
+ if (!outfile)
+ return;
+ // if any boxes are used then this is a proquake-format loc file, which
+ // allows comments, so add some relevant information at the start
+ for (loc = cl.locnodes;loc;loc = loc->next)
+ if (!VectorCompare(loc->mins, loc->maxs))
+ break;
+ if (loc)
+ {
+ FS_Printf(outfile, "// %s %s saved by %s\n// x,y,z,x,y,z,\"name\"\n\n", locfilename, Sys_TimeString("%Y-%m-%d"), engineversion);
+ for (loc = cl.locnodes;loc;loc = loc->next)
+ if (VectorCompare(loc->mins, loc->maxs))
+ break;
+ if (loc)
+ Con_Printf("Warning: writing loc file containing a mixture of qizmo-style points and proquake-style boxes may not work in qizmo or proquake!\n");
+ }
+ for (loc = cl.locnodes;loc;loc = loc->next)
+ {
+ if (VectorCompare(loc->mins, loc->maxs))
+ {
+ int len;
+ const char *s;
+ const char *in = loc->name;
+ char name[MAX_INPUTLINE];
+ for (len = 0;len < (int)sizeof(name) - 1 && *in;)
+ {
+ if (*in == ' ') {s = "$loc_name_separator";in++;}
+ else if (!strncmp(in, "SSG", 3)) {s = "$loc_name_ssg";in += 3;}
+ else if (!strncmp(in, "NG", 2)) {s = "$loc_name_ng";in += 2;}
+ else if (!strncmp(in, "SNG", 3)) {s = "$loc_name_sng";in += 3;}
+ else if (!strncmp(in, "GL", 2)) {s = "$loc_name_gl";in += 2;}
+ else if (!strncmp(in, "RL", 2)) {s = "$loc_name_rl";in += 2;}
+ else if (!strncmp(in, "LG", 2)) {s = "$loc_name_lg";in += 2;}
+ else if (!strncmp(in, "GA", 2)) {s = "$loc_name_ga";in += 2;}
+ else if (!strncmp(in, "YA", 2)) {s = "$loc_name_ya";in += 2;}
+ else if (!strncmp(in, "RA", 2)) {s = "$loc_name_ra";in += 2;}
+ else if (!strncmp(in, "MEGA", 4)) {s = "$loc_name_mh";in += 4;}
+ else s = NULL;
+ if (s)
+ {
+ while (len < (int)sizeof(name) - 1 && *s)
+ name[len++] = *s++;
+ continue;
+ }
+ name[len++] = *in++;
+ }
+ name[len] = 0;
+ FS_Printf(outfile, "%.0f %.0f %.0f %s\n", loc->mins[0]*8, loc->mins[1]*8, loc->mins[2]*8, name);
+ }
+ else
+ FS_Printf(outfile, "%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,\"%s\"\n", loc->mins[0], loc->mins[1], loc->mins[2], loc->maxs[0], loc->maxs[1], loc->maxs[2], loc->name);
+ }
+ FS_Close(outfile);
+}
+
+void CL_Locs_Reload_f(void)
+{
+ int i, linenumber, limit, len;
+ const char *s;
+ char *filedata, *text, *textend, *linestart, *linetext, *lineend;
+ fs_offset_t filesize;
+ vec3_t mins, maxs;
+ char locfilename[MAX_QPATH];
+ char name[MAX_INPUTLINE];
+
+ if (cls.state != ca_connected || !cl.worldmodel)
+ {
+ Con_Printf("No level loaded!\n");
+ return;
+ }
+
+ CL_Locs_Clear_f();
+
+ // try maps/something.loc first (LordHavoc: where I think they should be)
+ FS_StripExtension(cl.worldmodel->name, locfilename, sizeof(locfilename));
+ strlcat(locfilename, ".loc", sizeof(locfilename));
+ filedata = (char *)FS_LoadFile(locfilename, cls.levelmempool, false, &filesize);
+ if (!filedata)
+ {
+ // try proquake name as well (LordHavoc: I hate path mangling)
+ FS_StripExtension(va("locs/%s", FS_FileWithoutPath(cl.worldmodel->name)), locfilename, sizeof(locfilename));
+ strlcat(locfilename, ".loc", sizeof(locfilename));
+ filedata = (char *)FS_LoadFile(locfilename, cls.levelmempool, false, &filesize);
+ if (!filedata)
+ return;
+ }
+ text = filedata;
+ textend = filedata + filesize;
+ for (linenumber = 1;text < textend;linenumber++)
+ {
+ linestart = text;
+ for (;text < textend && *text != '\r' && *text != '\n';text++)
+ ;
+ lineend = text;
+ if (text + 1 < textend && *text == '\r' && text[1] == '\n')
+ text++;
+ if (text < textend)
+ text++;
+ // trim trailing whitespace
+ while (lineend > linestart && lineend[-1] <= ' ')
+ lineend--;
+ // trim leading whitespace
+ while (linestart < lineend && *linestart <= ' ')
+ linestart++;
+ // check if this is a comment
+ if (linestart + 2 <= lineend && !strncmp(linestart, "//", 2))
+ continue;
+ linetext = linestart;
+ limit = 3;
+ for (i = 0;i < limit;i++)
+ {
+ if (linetext >= lineend)
+ break;
+ // note: a missing number is interpreted as 0
+ if (i < 3)
+ mins[i] = atof(linetext);
+ else
+ maxs[i - 3] = atof(linetext);
+ // now advance past the number
+ while (linetext < lineend && *linetext > ' ' && *linetext != ',')
+ linetext++;
+ // advance through whitespace
+ if (linetext < lineend)
+ {
+ if (*linetext == ',')
+ {
+ linetext++;
+ limit = 6;
+ // note: comma can be followed by whitespace
+ }
+ if (*linetext <= ' ')
+ {
+ // skip whitespace
+ while (linetext < lineend && *linetext <= ' ')
+ linetext++;
+ }
+ }
+ }
+ // if this is a quoted name, remove the quotes
+ if (i == 6)
+ {
+ if (linetext >= lineend || *linetext != '"')
+ continue; // proquake location names are always quoted
+ lineend--;
+ linetext++;
+ len = min(lineend - linetext, (int)sizeof(name) - 1);
+ memcpy(name, linetext, len);
+ name[len] = 0;
+ // add the box to the list
+ CL_Locs_AddNode(mins, maxs, name);
+ }
+ // if a point was parsed, it needs to be scaled down by 8 (since
+ // point-based loc files were invented by a proxy which dealt
+ // directly with quake protocol coordinates, which are *8), turn
+ // it into a box
+ else if (i == 3)
+ {
+ // interpret silly fuhquake macros
+ for (len = 0;len < (int)sizeof(name) - 1 && linetext < lineend;)
+ {
+ if (*linetext == '$')
+ {
+ if (linetext + 18 <= lineend && !strncmp(linetext, "$loc_name_separator", 19)) {s = " ";linetext += 19;}
+ else if (linetext + 13 <= lineend && !strncmp(linetext, "$loc_name_ssg", 13)) {s = "SSG";linetext += 13;}
+ else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_ng", 12)) {s = "NG";linetext += 12;}
+ else if (linetext + 13 <= lineend && !strncmp(linetext, "$loc_name_sng", 13)) {s = "SNG";linetext += 13;}
+ else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_gl", 12)) {s = "GL";linetext += 12;}
+ else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_rl", 12)) {s = "RL";linetext += 12;}
+ else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_lg", 12)) {s = "LG";linetext += 12;}
+ else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_ga", 12)) {s = "GA";linetext += 12;}
+ else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_ya", 12)) {s = "YA";linetext += 12;}
+ else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_ra", 12)) {s = "RA";linetext += 12;}
+ else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_mh", 12)) {s = "MEGA";linetext += 12;}
+ else s = NULL;
+ if (s)
+ {
+ while (len < (int)sizeof(name) - 1 && *s)
+ name[len++] = *s++;
+ continue;
+ }
+ }
+ name[len++] = *linetext++;
+ }
+ name[len] = 0;
+ // add the point to the list
+ VectorScale(mins, (1.0 / 8.0), mins);
+ CL_Locs_AddNode(mins, mins, name);
+ }
+ else
+ continue;
+ }
+}
+
/*
===========
CL_Shutdown
*/
void CL_Shutdown (void)
{
+ CL_Screen_Shutdown();
CL_Particles_Shutdown();
CL_Parse_Shutdown();
Cmd_AddCommand ("playdemo", CL_PlayDemo_f, "watch a demo file");
Cmd_AddCommand ("timedemo", CL_TimeDemo_f, "play back a demo as fast as possible and save statistics to benchmark.log");
-#ifdef AUTODEMO_BROKEN
+ // Support Client-side Model Index List
+ Cmd_AddCommand ("cl_modelindexlist", CL_ModelIndexList_f, "list all models in the client modelindex");
+
Cvar_RegisterVariable (&cl_autodemo);
Cvar_RegisterVariable (&cl_autodemo_nameformat);
-#endif
Cmd_AddCommand ("fog", CL_Fog_f, "set global fog parameters (density red green blue)");
Cvar_RegisterVariable(&cl_beams_instantaimhack);
Cvar_RegisterVariable(&cl_beams_lightatend);
Cvar_RegisterVariable(&cl_noplayershadow);
+ Cvar_RegisterVariable(&cl_dlights_decayradius);
+ Cvar_RegisterVariable(&cl_dlights_decaybrightness);
Cvar_RegisterVariable(&cl_prydoncursor);
Cmd_AddCommand("timerefresh", CL_TimeRefresh_f, "turn quickly and print rendering statistcs");
+ Cvar_RegisterVariable(&cl_locs_enable);
+ Cvar_RegisterVariable(&cl_locs_show);
+ Cmd_AddCommand("locs_add", CL_Locs_Add_f, "add a point or box location (usage: x y z[ x y z] \"name\", if two sets of xyz are supplied it is a box, otherwise point)");
+ Cmd_AddCommand("locs_removenearest", CL_Locs_RemoveNearest_f, "remove the nearest point or box (note: you need to be very near a box to remove it)");
+ Cmd_AddCommand("locs_clear", CL_Locs_Clear_f, "remove all loc points/boxes");
+ Cmd_AddCommand("locs_reload", CL_Locs_Reload_f, "reload .loc file for this map");
+ Cmd_AddCommand("locs_save", CL_Locs_Save_f, "save .loc file for this map containing currently defined points and boxes");
+
CL_Parse_Init();
CL_Particles_Init();
CL_Screen_Init();
projects / xonotic / darkplaces.git / blobdiff