X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=cl_main.c;h=3a238c3ffa40d5340b244fc704f74d949c2fc2d4;hp=8c8868d9257d17f6c784039eee3c3f97b9466408;hb=00ca5f39cd5c7640de9c915c1f6792f2bd4108d9;hpb=02887205005a6e2ebc619ff1b60785d384cab237

diff --git a/cl_main.c b/cl_main.c
index 8c8868d9..3a238c3f 100644
--- a/cl_main.c
+++ b/cl_main.c
@@ -20,6 +20,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 // cl_main.c  -- client main loop
 
 #include "quakedef.h"
+#include "cl_collision.h"
+#include "cl_video.h"
 
 // we need to declare some mouse variables here, because the menu system
 // references them even when on a unix system.
@@ -46,38 +48,41 @@ cvar_t m_side = {CVAR_SAVE, "m_side","0.8"};
 
 cvar_t freelook = {CVAR_SAVE, "freelook", "1"};
 
-cvar_t cl_draweffects = {0, "cl_draweffects", "1"};
+cvar_t r_draweffects = {0, "r_draweffects", "1"};
+
+cvar_t cl_explosions = {CVAR_SAVE, "cl_explosions", "1"};
+cvar_t cl_stainmaps = {CVAR_SAVE, "cl_stainmaps", "1"};
 
 mempool_t *cl_scores_mempool;
 mempool_t *cl_refdef_mempool;
+mempool_t *cl_entities_mempool;
 
 client_static_t	cls;
 client_state_t	cl;
-// FIXME: put these on hunk?
-entity_t		cl_entities[MAX_EDICTS];
-entity_t		cl_static_entities[MAX_STATIC_ENTITIES];
-lightstyle_t	cl_lightstyle[MAX_LIGHTSTYLES];
-
-typedef struct effect_s
-{
-	int active;
-	vec3_t origin;
-	float starttime;
-	float framerate;
-	int modelindex;
-	int startframe;
-	int endframe;
-	// these are for interpolation
-	int frame;
-	double frame1time;
-	double frame2time;
-}
-cl_effect_t;
-
-#define MAX_EFFECTS 256
-
-static cl_effect_t cl_effect[MAX_EFFECTS];
 
+int cl_max_entities;
+int cl_max_static_entities;
+int cl_max_temp_entities;
+int cl_max_effects;
+int cl_max_beams;
+int cl_max_dlights;
+int cl_max_lightstyle;
+int cl_max_brushmodel_entities;
+
+entity_t *cl_entities;
+qbyte *cl_entities_active;
+entity_t *cl_static_entities;
+entity_t *cl_temp_entities;
+cl_effect_t *cl_effects;
+beam_t *cl_beams;
+dlight_t *cl_dlights;
+lightstyle_t *cl_lightstyle;
+entity_render_t **cl_brushmodel_entities;
+
+int cl_num_entities;
+int cl_num_static_entities;
+int cl_num_temp_entities;
+int cl_num_brushmodel_entities;
 
 /*
 =====================
@@ -87,30 +92,50 @@ CL_ClearState
 */
 void CL_ClearState (void)
 {
-	int			i;
+	int i;
 
 	if (!sv.active)
 		Host_ClearMemory ();
 
 	Mem_EmptyPool(cl_scores_mempool);
+	Mem_EmptyPool(cl_entities_mempool);
 
 // wipe the entire cl structure
 	memset (&cl, 0, sizeof(cl));
 
 	SZ_Clear (&cls.message);
 
-// clear other arrays
-	memset(cl_entities, 0, sizeof(cl_entities));
-	memset(cl_lightstyle, 0, sizeof(cl_lightstyle));
-	memset(cl_temp_entities, 0, sizeof(cl_temp_entities));
-	memset(cl_beams, 0, sizeof(cl_beams));
-	memset(cl_dlights, 0, sizeof(cl_dlights));
-	memset(cl_effect, 0, sizeof(cl_effect));
+	cl_num_entities = 0;
+	cl_num_static_entities = 0;
+	cl_num_temp_entities = 0;
+	cl_num_brushmodel_entities = 0;
+
+	// tweak these if the game runs out
+	cl_max_entities = MAX_EDICTS;
+	cl_max_static_entities = 256;
+	cl_max_temp_entities = 512;
+	cl_max_effects = 256;
+	cl_max_beams = 24;
+	cl_max_dlights = MAX_DLIGHTS;
+	cl_max_lightstyle = MAX_LIGHTSTYLES;
+	cl_max_brushmodel_entities = MAX_EDICTS;
+
+	cl_entities = Mem_Alloc(cl_entities_mempool, cl_max_entities * sizeof(entity_t));
+	cl_entities_active = Mem_Alloc(cl_entities_mempool, cl_max_entities * sizeof(qbyte));
+	cl_static_entities = Mem_Alloc(cl_entities_mempool, cl_max_static_entities * sizeof(entity_t));
+	cl_temp_entities = Mem_Alloc(cl_entities_mempool, cl_max_temp_entities * sizeof(entity_t));
+	cl_effects = Mem_Alloc(cl_entities_mempool, cl_max_effects * sizeof(cl_effect_t));
+	cl_beams = Mem_Alloc(cl_entities_mempool, cl_max_beams * sizeof(beam_t));
+	cl_dlights = Mem_Alloc(cl_entities_mempool, cl_max_dlights * sizeof(dlight_t));
+	cl_lightstyle = Mem_Alloc(cl_entities_mempool, cl_max_lightstyle * sizeof(lightstyle_t));
+	cl_brushmodel_entities = Mem_Alloc(cl_entities_mempool, cl_max_brushmodel_entities * sizeof(entity_render_t *));
+
 	CL_Screen_NewMap();
+
 	CL_Particles_Clear();
-	CL_Decals_Clear();
+
 	// LordHavoc: have to set up the baseline info for alpha and other stuff
-	for (i = 0;i < MAX_EDICTS;i++)
+	for (i = 0;i < cl_max_entities;i++)
 	{
 		ClearStateToDefault(&cl_entities[i].state_baseline);
 		ClearStateToDefault(&cl_entities[i].state_previous);
@@ -120,47 +145,6 @@ void CL_ClearState (void)
 	CL_CGVM_Clear();
 }
 
-void CL_LerpUpdate(entity_t *e)
-{
-	entity_persistent_t *p;
-	entity_render_t *r;
-	p = &e->persistent;
-	r = &e->render;
-
-	if (p->modelindex != e->state_current.modelindex)
-	{
-		// reset all interpolation information
-		p->modelindex = e->state_current.modelindex;
-		p->frame1 = p->frame2 = e->state_current.frame;
-		p->frame1time = p->frame2time = cl.time;
-		p->framelerp = 1;
-	}
-	else if (p->frame2 != e->state_current.frame)
-	{
-		// transition to new frame
-		p->frame1 = p->frame2;
-		p->frame1time = p->frame2time;
-		p->frame2 = e->state_current.frame;
-		p->frame2time = cl.time;
-		p->framelerp = 0;
-	}
-	else
-	{
-		// update transition
-		p->framelerp = (cl.time - p->frame2time) * 10;
-		p->framelerp = bound(0, p->framelerp, 1);
-	}
-
-	r->model = cl.model_precache[e->state_current.modelindex];
-	Mod_CheckLoaded(r->model);
-	r->frame = e->state_current.frame;
-	r->frame1 = p->frame1;
-	r->frame2 = p->frame2;
-	r->framelerp = p->framelerp;
-	r->frame1time = p->frame1time;
-	r->frame2time = p->frame2time;
-}
-
 /*
 =====================
 CL_Disconnect
@@ -198,6 +182,7 @@ void CL_Disconnect (void)
 		NET_SendUnreliableMessage (cls.netcon, &cls.message);
 		SZ_Clear (&cls.message);
 		NET_Close (cls.netcon);
+		cls.state = ca_disconnected; // prevent this code from executing again during Host_ShutdownServer
 		// if running a local server, shut it down
 		if (sv.active)
 			Host_ShutdownServer(false);
@@ -243,6 +228,8 @@ void CL_EstablishConnection (char *host)
 	cls.demonum = -1;			// not in the demo loop now
 	cls.state = ca_connected;
 	cls.signon = 0;				// need all the signon messages before playing
+
+	CL_ClearState ();
 }
 
 /*
@@ -252,31 +239,97 @@ CL_PrintEntities_f
 */
 static void CL_PrintEntities_f (void)
 {
-	entity_t	*ent;
-	int			i, j;
-	char		name[32];
+	entity_t *ent;
+	int i, j;
+	char name[32];
 
-	for (i = 0, ent = cl_entities;i < MAX_EDICTS /*cl.num_entities*/;i++, ent++)
+	for (i = 0, ent = cl_entities;i < cl_num_entities;i++, ent++)
 	{
 		if (!ent->state_current.active)
 			continue;
-		if (!ent->render.model)
-			continue;
 
-		Con_Printf ("%3i:", i);
-		if (!ent->render.model)
-		{
-			Con_Printf ("EMPTY\n");
-			continue;
-		}
-		strncpy(name, ent->render.model->name, 25);
+		if (ent->render.model)
+			strncpy(name, ent->render.model->name, 25);
+		else
+			strcpy(name, "--no model--");
 		name[25] = 0;
 		for (j = strlen(name);j < 25;j++)
 			name[j] = ' ';
-		Con_Printf ("%s:%04i (%5i %5i %5i) [%3i %3i %3i] %4.2f %5.3f\n", name, ent->render.frame, (int) ent->render.origin[0], (int) ent->render.origin[1], (int) ent->render.origin[2], (int) ent->render.angles[0] % 360, (int) ent->render.angles[1] % 360, (int) ent->render.angles[2] % 360, ent->render.scale, ent->render.alpha);
+		Con_Printf ("%3i: %s:%04i (%5i %5i %5i) [%3i %3i %3i] %4.2f %5.3f\n", i, name, ent->render.frame, (int) ent->render.origin[0], (int) ent->render.origin[1], (int) ent->render.origin[2], (int) ent->render.angles[0] % 360, (int) ent->render.angles[1] % 360, (int) ent->render.angles[2] % 360, ent->render.scale, ent->render.alpha);
+	}
+}
+
+static const vec3_t nomodelmins = {-16, -16, -16};
+static const vec3_t nomodelmaxs = {16, 16, 16};
+void CL_BoundingBoxForEntity(entity_render_t *ent)
+{
+	if (ent->model)
+	{
+		if (ent->angles[0] || ent->angles[2])
+		{
+			// pitch or roll
+			VectorAdd(ent->origin, ent->model->rotatedmins, ent->mins);
+			VectorAdd(ent->origin, ent->model->rotatedmaxs, ent->maxs);
+		}
+		else if (ent->angles[1])
+		{
+			// yaw
+			VectorAdd(ent->origin, ent->model->yawmins, ent->mins);
+			VectorAdd(ent->origin, ent->model->yawmaxs, ent->maxs);
+		}
+		else
+		{
+			VectorAdd(ent->origin, ent->model->normalmins, ent->mins);
+			VectorAdd(ent->origin, ent->model->normalmaxs, ent->maxs);
+		}
+	}
+	else
+	{
+		VectorAdd(ent->origin, nomodelmins, ent->mins);
+		VectorAdd(ent->origin, nomodelmaxs, ent->maxs);
 	}
 }
 
+void CL_LerpUpdate(entity_t *e)
+{
+	entity_persistent_t *p;
+	entity_render_t *r;
+	p = &e->persistent;
+	r = &e->render;
+
+	if (p->modelindex != e->state_current.modelindex)
+	{
+		// reset all interpolation information
+		p->modelindex = e->state_current.modelindex;
+		p->frame1 = p->frame2 = e->state_current.frame;
+		p->frame1time = p->frame2time = cl.time;
+		p->framelerp = 1;
+	}
+	else if (p->frame2 != e->state_current.frame)
+	{
+		// transition to new frame
+		p->frame1 = p->frame2;
+		p->frame1time = p->frame2time;
+		p->frame2 = e->state_current.frame;
+		p->frame2time = cl.time;
+		p->framelerp = 0;
+	}
+	else
+	{
+		// update transition
+		p->framelerp = (cl.time - p->frame2time) * 10;
+		p->framelerp = bound(0, p->framelerp, 1);
+	}
+
+	r->model = cl.model_precache[e->state_current.modelindex];
+	Mod_CheckLoaded(r->model);
+	r->frame = e->state_current.frame;
+	r->frame1 = p->frame1;
+	r->frame2 = p->frame2;
+	r->framelerp = p->framelerp;
+	r->frame1time = p->frame1time;
+	r->frame2time = p->frame2time;
+}
 
 /*
 ===============
@@ -288,50 +341,127 @@ should be put at.
 */
 static float CL_LerpPoint (void)
 {
-	float	f, frac;
+	float f;
 
-	f = cl.mtime[0] - cl.mtime[1];
+	// dropped packet, or start of demo
+	if (cl.mtime[1] < cl.mtime[0] - 0.1)
+		cl.mtime[1] = cl.mtime[0] - 0.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)
+	f = cl.mtime[0] - cl.mtime[1];
 	if (!f || cl_nolerp.integer || cls.timedemo || (sv.active && svs.maxclients == 1))
 	{
 		cl.time = cl.mtime[0];
 		return 1;
 	}
 
-	if (f > 0.1)
-	{	// dropped packet, or start of demo
-		cl.mtime[1] = cl.mtime[0] - 0.1;
-		f = 0.1;
-	}
-	frac = (cl.time - cl.mtime[1]) / f;
-//	Con_Printf ("frac: %f\n",frac);
-	if (frac < 0)
+	f = (cl.time - cl.mtime[1]) / f;
+	return bound(0, f, 1);
+}
+
+void CL_ClearTempEntities (void)
+{
+	cl_num_temp_entities = 0;
+}
+
+entity_t *CL_NewTempEntity (void)
+{
+	entity_t *ent;
+
+	if (r_refdef.numentities >= r_refdef.maxentities)
+		return NULL;
+	if (cl_num_temp_entities >= cl_max_temp_entities)
+		return NULL;
+	ent = &cl_temp_entities[cl_num_temp_entities++];
+	memset (ent, 0, sizeof(*ent));
+	r_refdef.entities[r_refdef.numentities++] = &ent->render;
+
+	ent->render.colormap = -1; // no special coloring
+	ent->render.scale = 1;
+	ent->render.alpha = 1;
+	return ent;
+}
+
+void CL_AllocDlight (entity_render_t *ent, vec3_t org, float radius, float red, float green, float blue, float decay, float lifetime)
+{
+	int i;
+	dlight_t *dl;
+
+	/*
+// first look for an exact key match
+	if (ent)
 	{
-		if (frac < -0.01)
-		{
-			cl.time = cl.mtime[1];
-//			Con_Printf ("low frac\n");
-		}
-		frac = 0;
+		dl = cl_dlights;
+		for (i = 0;i < MAX_DLIGHTS;i++, dl++)
+			if (dl->ent == ent)
+				goto dlightsetup;
 	}
-	else if (frac > 1)
+	*/
+
+// then look for anything else
+	dl = cl_dlights;
+	for (i = 0;i < MAX_DLIGHTS;i++, dl++)
+		if (!dl->radius)
+			goto dlightsetup;
+
+	// unable to find one
+	return;
+
+dlightsetup:
+	//Con_Printf("dlight %i : %f %f %f : %f %f %f\n", i, org[0], org[1], org[2], red * radius, green * radius, blue * radius);
+	memset (dl, 0, sizeof(*dl));
+	dl->ent = ent;
+	VectorCopy(org, dl->origin);
+	dl->radius = radius;
+	dl->color[0] = red;
+	dl->color[1] = green;
+	dl->color[2] = blue;
+	dl->decay = decay;
+	if (lifetime)
+		dl->die = cl.time + lifetime;
+	else
+		dl->die = 0;
+}
+
+void CL_DecayLights (void)
+{
+	int i;
+	dlight_t *dl;
+	float time;
+
+	time = cl.time - cl.oldtime;
+
+	dl = cl_dlights;
+	for (i=0 ; i<MAX_DLIGHTS ; i++, dl++)
 	{
-		if (frac > 1.01)
+		if (!dl->radius)
+			continue;
+		if (dl->die < cl.time)
 		{
-			cl.time = cl.mtime[0];
-//			Con_Printf ("high frac\n");
+			dl->radius = 0;
+			continue;
 		}
-		frac = 1;
+
+		dl->radius -= time*dl->decay;
+		if (dl->radius < 0)
+			dl->radius = 0;
 	}
+}
 
-	return frac;
+void CL_RelinkWorld (void)
+{
+	if (cl_num_entities < 1)
+		cl_num_entities = 1;
+	cl_brushmodel_entities[cl_num_brushmodel_entities++] = &cl_entities[0].render;
+	CL_BoundingBoxForEntity(&cl_entities[0].render);
 }
 
 static void CL_RelinkStaticEntities(void)
 {
 	int i;
-	for (i = 0;i < cl.num_statics && r_refdef.numentities < MAX_VISEDICTS;i++)
+	for (i = 0;i < cl_num_static_entities && r_refdef.numentities < r_refdef.maxentities;i++)
 	{
 		Mod_CheckLoaded(cl_static_entities[i].render.model);
 		r_refdef.entities[r_refdef.numentities++] = &cl_static_entities[i].render;
@@ -343,12 +473,12 @@ static void CL_RelinkStaticEntities(void)
 CL_RelinkEntities
 ===============
 */
-static void CL_RelinkNetworkEntities()
+static void CL_RelinkNetworkEntities(void)
 {
-	entity_t	*ent;
-	int			i, glowcolor, effects;
-	float		f, d, bobjrotate, bobjoffset, dlightradius, glowsize, lerp;
-	vec3_t		oldorg, neworg, delta, dlightcolor;
+	entity_t *ent;
+	int i, effects, temp;
+	float d, bobjrotate, bobjoffset, lerp;
+	vec3_t oldorg, neworg, delta, dlightcolor, v, v2, mins, maxs;
 
 	bobjrotate = ANGLEMOD(100*cl.time);
 	if (cl_itembobheight.value)
@@ -356,112 +486,56 @@ static void CL_RelinkNetworkEntities()
 	else
 		bobjoffset = 0;
 
-	CL_RelinkStaticEntities();
-
-// start on the entity after the world
-	for (i = 1, ent = cl_entities + 1;i < MAX_EDICTS /*cl.num_entities*/;i++, ent++)
+	// start on the entity after the world
+	for (i = 1, ent = cl_entities + 1;i < MAX_EDICTS;i++, ent++)
 	{
-		// if the object wasn't included in the latest packet, remove it
+		// if the object isn't active in the current network frame, skip it
+		if (!cl_entities_active[i])
+			continue;
 		if (!ent->state_current.active)
+		{
+			cl_entities_active[i] = false;
 			continue;
+		}
 
 		VectorCopy(ent->persistent.trail_origin, oldorg);
 
 		if (!ent->state_previous.active)
 		{
 			// only one state available
-			lerp = 1;
-			VectorCopy (ent->state_current.origin, oldorg); // skip trails
-			VectorCopy (ent->state_current.origin, neworg);
-			VectorCopy (ent->state_current.angles, ent->render.angles);
-
-			/*
-			// monster interpolation
-			ent->persistent.steplerptime = 0;
-			VectorCopy(ent->state_current.origin, ent->persistent.stepoldorigin);
-			VectorCopy(ent->state_current.angles, ent->persistent.stepoldangles);
-			VectorCopy(ent->state_current.origin, ent->persistent.steporigin);
-			VectorCopy(ent->state_current.angles, ent->persistent.stepangles);
-			*/
-		}
-		/*
-		else if ((ent->state_current.flags & ent->state_previous.flags) & ENTFLAG_STEP)
-		{
-			if (ent->state_current.origin[0] != ent->persistent.steporigin[0]
-			 || ent->state_current.origin[1] != ent->persistent.steporigin[1]
-			 || ent->state_current.origin[2] != ent->persistent.steporigin[2]
-			 || ent->state_current.angles[0] != ent->persistent.stepangles[0]
-			 || ent->state_current.angles[1] != ent->persistent.stepangles[1]
-			 || ent->state_current.angles[2] != ent->persistent.stepangles[2])
-			{
-				// update lerp positions
-				ent->clientpersistent.steplerptime = sv.time;
-				VectorCopy(ent->steporigin, ent->stepoldorigin);
-				VectorCopy(ent->stepangles, ent->stepoldangles);
-				VectorCopy(ent->v.origin, ent->steporigin);
-				VectorCopy(ent->v.angles, ent->stepangles);
-			}
-			lerp = (cl.time - ent->persistent.steplerptime) * 10.0;
-			if (lerp < 1)
-			{
-				// origin
-				VectorSubtract(ent->persistent.steporigin, ent->persistent.stepoldorigin, delta);
-				VectorMA(ent->persistent.stepoldorigin, lerp, delta, neworg);
-
-				// angles
-				VectorSubtract(ent->persistent.stepangles, ent->persistent.stepoldangles, delta);
-				// choose shortest rotate (to avoid 'spin around' situations)
-				if (delta[0] < -180) delta[0] += 360;else if (delta[0] >= 180) delta[0] -= 360;
-				if (delta[1] < -180) delta[1] += 360;else if (delta[1] >= 180) delta[1] -= 360;
-				if (delta[2] < -180) delta[2] += 360;else if (delta[2] >= 180) delta[2] -= 360;
-				VectorMA(ent->stepoldangles, lerp, delta, ent->render.angles);
-			}
-			else
-			{
-				VectorCopy(ent->persistent.steporigin, neworg);
-				VectorCopy(ent->persistent.stepangles, ent->render.angles);
-			}
+			VectorCopy (ent->persistent.neworigin, neworg);
+			VectorCopy (ent->persistent.newangles, ent->render.angles);
+			VectorCopy (neworg, oldorg);
 		}
-		*/
 		else
 		{
-			/*
-			// monster interpolation
-			ent->persistent.steplerptime = 0;
-			VectorCopy(ent->state_current.origin, ent->persistent.stepoldorigin);
-			VectorCopy(ent->state_current.angles, ent->persistent.stepoldangles);
-			VectorCopy(ent->state_current.origin, ent->persistent.steporigin);
-			VectorCopy(ent->state_current.angles, ent->persistent.stepangles);
-			*/
-
 			// if the delta is large, assume a teleport and don't lerp
-			VectorSubtract(ent->state_current.origin, ent->state_previous.origin, delta);
-			// LordHavoc: increased tolerance from 100 to 200, and now to 1000
-			if ((sv.active && svs.maxclients == 1 && !(ent->state_current.flags & RENDER_STEP)) || cls.timedemo || DotProduct(delta, delta) > 1000*1000 || cl_nolerp.integer)
-				lerp = 1;
-			else
+			VectorSubtract(ent->persistent.neworigin, ent->persistent.oldorigin, delta);
+			if (ent->persistent.lerpdeltatime > 0)
 			{
-				f = ent->state_current.time - ent->state_previous.time;
-				if (f > 0)
-					lerp = (cl.time - ent->state_previous.time) / f;
+				lerp = (cl.time - ent->persistent.lerpstarttime) / ent->persistent.lerpdeltatime;
+				if (lerp < 1)
+				{
+					// interpolate the origin and angles
+					VectorMA(ent->persistent.oldorigin, lerp, delta, neworg);
+					VectorSubtract(ent->persistent.newangles, ent->persistent.oldangles, delta);
+					if (delta[0] < -180) delta[0] += 360;else if (delta[0] >= 180) delta[0] -= 360;
+					if (delta[1] < -180) delta[1] += 360;else if (delta[1] >= 180) delta[1] -= 360;
+					if (delta[2] < -180) delta[2] += 360;else if (delta[2] >= 180) delta[2] -= 360;
+					VectorMA(ent->persistent.oldangles, lerp, delta, ent->render.angles);
+				}
 				else
-					lerp = 1;
-			}
-			if (lerp >= 1)
-			{
-				// no interpolation
-				VectorCopy (ent->state_current.origin, neworg);
-				VectorCopy (ent->state_current.angles, ent->render.angles);
+				{
+					// no interpolation
+					VectorCopy (ent->persistent.neworigin, neworg);
+					VectorCopy (ent->persistent.newangles, ent->render.angles);
+				}
 			}
 			else
 			{
-				// interpolate the origin and angles
-				VectorMA(ent->state_previous.origin, lerp, delta, neworg);
-				VectorSubtract(ent->state_current.angles, ent->state_previous.angles, delta);
-				if (delta[0] < -180) delta[0] += 360;else if (delta[0] >= 180) delta[0] -= 360;
-				if (delta[1] < -180) delta[1] += 360;else if (delta[1] >= 180) delta[1] -= 360;
-				if (delta[2] < -180) delta[2] += 360;else if (delta[2] >= 180) delta[2] -= 360;
-				VectorMA(ent->state_previous.angles, lerp, delta, ent->render.angles);
+				// no interpolation
+				VectorCopy (ent->persistent.neworigin, neworg);
+				VectorCopy (ent->persistent.newangles, ent->render.angles);
 			}
 		}
 
@@ -472,8 +546,12 @@ static void CL_RelinkNetworkEntities()
 
 		VectorCopy (neworg, ent->render.origin);
 		ent->render.flags = ent->state_current.flags;
+		if (i == cl.viewentity)
+			ent->render.flags |= RENDER_EXTERIORMODEL;
 		ent->render.effects = effects = ent->state_current.effects;
-		if (cl.scores == NULL || !ent->state_current.colormap)
+		if (ent->state_current.flags & RENDER_COLORMAPPED)
+			ent->render.colormap = ent->state_current.colormap;
+		else if (cl.scores == NULL || !ent->state_current.colormap)
 			ent->render.colormap = -1; // no special coloring
 		else
 			ent->render.colormap = cl.scores[ent->state_current.colormap - 1].colors; // color it
@@ -485,7 +563,6 @@ static void CL_RelinkNetworkEntities()
 		CL_LerpUpdate(ent);
 
 		// handle effects now...
-		dlightradius = 0;
 		dlightcolor[0] = 0;
 		dlightcolor[1] = 0;
 		dlightcolor[2] = 0;
@@ -496,18 +573,7 @@ static void CL_RelinkNetworkEntities()
 			if (effects & EF_BRIGHTFIELD)
 				CL_EntityParticles (ent);
 			if (effects & EF_MUZZLEFLASH)
-			{
-				vec3_t v, v2;
-
-				AngleVectors (ent->render.angles, v, NULL, NULL);
-
-				v2[0] = v[0] * 18 + neworg[0];
-				v2[1] = v[1] * 18 + neworg[1];
-				v2[2] = v[2] * 18 + neworg[2] + 16;
-				TraceLine(neworg, v2, v, NULL, 0, true);
-
-				CL_AllocDlight (NULL, v, 100, 1, 1, 1, 0, 0);
-			}
+				ent->persistent.muzzleflash = 100.0f;
 			if (effects & EF_DIMLIGHT)
 			{
 				dlightcolor[0] += 200.0f;
@@ -537,23 +603,12 @@ static void CL_RelinkNetworkEntities()
 			{
 				if (ent->render.model)
 				{
-					vec3_t mins, maxs;
-					int temp;
-					if (ent->render.angles[0] || ent->render.angles[2])
-					{
-						VectorAdd(neworg, ent->render.model->rotatedmins, mins);
-						VectorAdd(neworg, ent->render.model->rotatedmaxs, maxs);
-					}
-					else if (ent->render.angles[1])
-					{
-						VectorAdd(neworg, ent->render.model->yawmins, mins);
-						VectorAdd(neworg, ent->render.model->yawmaxs, maxs);
-					}
-					else
-					{
-						VectorAdd(neworg, ent->render.model->normalmins, mins);
-						VectorAdd(neworg, ent->render.model->normalmaxs, maxs);
-					}
+					mins[0] = neworg[0] - 16.0f;
+					mins[1] = neworg[1] - 16.0f;
+					mins[2] = neworg[2] - 16.0f;
+					maxs[0] = neworg[0] + 16.0f;
+					maxs[1] = neworg[1] + 16.0f;
+					maxs[2] = neworg[2] + 16.0f;
 					// how many flames to make
 					temp = (int) (cl.time * 300) - (int) (cl.oldtime * 300);
 					CL_FlameCube(mins, maxs, temp);
@@ -563,6 +618,38 @@ static void CL_RelinkNetworkEntities()
 				dlightcolor[1] += d * 0.7f;
 				dlightcolor[2] += d * 0.3f;
 			}
+			if (effects & EF_STARDUST)
+			{
+				if (ent->render.model)
+				{
+					mins[0] = neworg[0] - 16.0f;
+					mins[1] = neworg[1] - 16.0f;
+					mins[2] = neworg[2] - 16.0f;
+					maxs[0] = neworg[0] + 16.0f;
+					maxs[1] = neworg[1] + 16.0f;
+					maxs[2] = neworg[2] + 16.0f;
+					// how many particles to make
+					temp = (int) (cl.time * 200) - (int) (cl.oldtime * 200);
+					CL_Stardust(mins, maxs, temp);
+				}
+				d = 100;
+				dlightcolor[0] += d * 1.0f;
+				dlightcolor[1] += d * 0.7f;
+				dlightcolor[2] += d * 0.3f;
+			}
+		}
+
+		if (ent->persistent.muzzleflash > 0)
+		{
+			AngleVectors (ent->render.angles, v, NULL, NULL);
+
+			v2[0] = v[0] * 18 + neworg[0];
+			v2[1] = v[1] * 18 + neworg[1];
+			v2[2] = v[2] * 18 + neworg[2] + 16;
+			CL_TraceLine(neworg, v2, v, NULL, 0, true, NULL);
+
+			CL_AllocDlight (NULL, v, ent->persistent.muzzleflash, 1, 1, 1, 0, 0);
+			ent->persistent.muzzleflash -= cl.frametime * 1000;
 		}
 
 		// LordHavoc: if the model has no flags, don't check each
@@ -581,97 +668,81 @@ static void CL_RelinkNetworkEntities()
 				else if (ent->render.model->flags & EF_ZOMGIB)
 					CL_RocketTrail (oldorg, neworg, 4, ent);
 				else if (ent->render.model->flags & EF_TRACER)
+				{
 					CL_RocketTrail (oldorg, neworg, 3, ent);
+					dlightcolor[0] += 0x10;
+					dlightcolor[1] += 0x40;
+					dlightcolor[2] += 0x10;
+				}
 				else if (ent->render.model->flags & EF_TRACER2)
+				{
 					CL_RocketTrail (oldorg, neworg, 5, ent);
+					dlightcolor[0] += 0x50;
+					dlightcolor[1] += 0x30;
+					dlightcolor[2] += 0x10;
+				}
 				else if (ent->render.model->flags & EF_ROCKET)
 				{
 					CL_RocketTrail (oldorg, ent->render.origin, 0, ent);
-					// LordHavoc: changed from 200, 160, 80 to 250, 200, 100
-					dlightcolor[0] += 250.0f;
-					dlightcolor[1] += 200.0f;
-					dlightcolor[2] += 100.0f;
+					dlightcolor[0] += 200.0f;
+					dlightcolor[1] += 160.0f;
+					dlightcolor[2] +=  80.0f;
 				}
 				else if (ent->render.model->flags & EF_GRENADE)
 				{
-					if (ent->render.alpha == -1) // LordHavoc: Nehahra dem compatibility
+					if (ent->render.alpha == -1) // LordHavoc: Nehahra dem compatibility (cigar smoke)
 						CL_RocketTrail (oldorg, neworg, 7, ent);
 					else
 						CL_RocketTrail (oldorg, neworg, 1, ent);
 				}
 				else if (ent->render.model->flags & EF_TRACER3)
+				{
 					CL_RocketTrail (oldorg, neworg, 6, ent);
+					dlightcolor[0] += 0x50;
+					dlightcolor[1] += 0x20;
+					dlightcolor[2] += 0x40;
+				}
 			}
 		}
 		// LordHavoc: customizable glow
-		glowsize = ent->state_current.glowsize * 4.0f; // FIXME: interpolate?
-		glowcolor = ent->state_current.glowcolor;
-		if (glowsize)
+		if (ent->state_current.glowsize)
 		{
-			byte *tempcolor = (byte *)&d_8to24table[glowcolor];
-			dlightcolor[0] += glowsize * tempcolor[0] * (1.0f / 255.0f);
-			dlightcolor[1] += glowsize * tempcolor[1] * (1.0f / 255.0f);
-			dlightcolor[2] += glowsize * tempcolor[2] * (1.0f / 255.0f);
+			// * 4 for the expansion from 0-255 to 0-1023 range,
+			// / 255 to scale down byte colors
+			VectorMA(dlightcolor, ent->state_current.glowsize * (4.0f / 255.0f), (qbyte *)&palette_complete[ent->state_current.glowcolor], dlightcolor);
 		}
 		// LordHavoc: customizable trail
 		if (ent->render.flags & RENDER_GLOWTRAIL)
-			CL_RocketTrail2 (oldorg, neworg, glowcolor, ent);
+			CL_RocketTrail2 (oldorg, neworg, ent->state_current.glowcolor, ent);
 
 		if (dlightcolor[0] || dlightcolor[1] || dlightcolor[2])
 		{
-			vec3_t vec;
-			dlightradius = VectorLength(dlightcolor);
-			d = 1.0f / dlightradius;
-			VectorCopy(neworg, vec);
+			VectorCopy(neworg, v);
 			// hack to make glowing player light shine on their gun
-			if (i == cl.viewentity && !chase_active.integer)
-				vec[2] += 30;
-			CL_AllocDlight (/*&ent->render*/ NULL, vec, dlightradius, dlightcolor[0] * d, dlightcolor[1] * d, dlightcolor[2] * d, 0, 0);
+			if (i == cl.viewentity/* && !chase_active.integer*/)
+				v[2] += 30;
+			CL_AllocDlight (&ent->render, v, 1, dlightcolor[0], dlightcolor[1], dlightcolor[2], 0, 0);
 		}
 
-		if (chase_active.integer)
-		{
-			if (ent->render.flags & RENDER_VIEWMODEL)
-				continue;
-		}
-		else
-		{
-			if (i == cl.viewentity || (ent->render.flags & RENDER_EXTERIORMODEL))
-				continue;
-		}
+		if (chase_active.integer && (ent->render.flags & RENDER_VIEWMODEL))
+			continue;
 
-		if (ent->render.model == NULL)
+		// don't show entities with no modelindex (note: this still shows
+		// entities which have a modelindex that resolved to a NULL model)
+		if (!ent->state_current.modelindex)
 			continue;
 		if (effects & EF_NODRAW)
 			continue;
-		if (r_refdef.numentities < MAX_VISEDICTS)
-			r_refdef.entities[r_refdef.numentities++] = &ent->render;
-	}
-}
 
-static void CL_LerpPlayerVelocity (void)
-{
-	int i;
-	float frac, d;
-
-	// fraction from previous network update to current
-	frac = CL_LerpPoint ();
+		CL_BoundingBoxForEntity(&ent->render);
+		if (ent->render.model && ent->render.model->name[0] == '*' && ent->render.model->type == mod_brush)
+			cl_brushmodel_entities[cl_num_brushmodel_entities++] = &ent->render;
 
-	for (i = 0;i < 3;i++)
-		cl.velocity[i] = cl.mvelocity[1][i] + frac * (cl.mvelocity[0][i] - cl.mvelocity[1][i]);
+		if (r_refdef.numentities < r_refdef.maxentities)
+			r_refdef.entities[r_refdef.numentities++] = &ent->render;
 
-	if (cls.demoplayback)
-	{
-		// interpolate the angles
-		for (i = 0;i < 3;i++)
-		{
-			d = cl.mviewangles[0][i] - cl.mviewangles[1][i];
-			if (d > 180)
-				d -= 360;
-			else if (d < -180)
-				d += 360;
-			cl.viewangles[i] = cl.mviewangles[1][i] + frac*d;
-		}
+		if (cl_num_entities < i + 1)
+			cl_num_entities = i + 1;
 	}
 }
 
@@ -681,7 +752,7 @@ void CL_Effect(vec3_t org, int modelindex, int startframe, int framecount, float
 	cl_effect_t *e;
 	if (!modelindex) // sanity check
 		return;
-	for (i = 0, e = cl_effect;i < MAX_EFFECTS;i++, e++)
+	for (i = 0, e = cl_effects;i < cl_max_effects;i++, e++)
 	{
 		if (e->active)
 			continue;
@@ -700,14 +771,14 @@ void CL_Effect(vec3_t org, int modelindex, int startframe, int framecount, float
 	}
 }
 
-static void CL_RelinkEffects()
+static void CL_RelinkEffects(void)
 {
 	int i, intframe;
 	cl_effect_t *e;
-	entity_t *vis;
+	entity_t *ent;
 	float frame;
 
-	for (i = 0, e = cl_effect;i < MAX_EFFECTS;i++, e++)
+	for (i = 0, e = cl_effects;i < cl_max_effects;i++, e++)
 	{
 		if (e->active)
 		{
@@ -727,39 +798,152 @@ static void CL_RelinkEffects()
 				e->frame2time = cl.time;
 			}
 
-			if ((vis = CL_NewTempEntity()))
+			// if we're drawing effects, get a new temp entity
+			// (NewTempEntity adds it to the render entities list for us)
+			if (r_draweffects.integer && (ent = CL_NewTempEntity()))
 			{
 				// interpolation stuff
-				vis->render.frame1 = intframe;
-				vis->render.frame2 = intframe + 1;
-				if (vis->render.frame2 >= e->endframe)
-					vis->render.frame2 = -1; // disappear
-				vis->render.framelerp = frame - intframe;
-				vis->render.frame1time = e->frame1time;
-				vis->render.frame2time = e->frame2time;
+				ent->render.frame1 = intframe;
+				ent->render.frame2 = intframe + 1;
+				if (ent->render.frame2 >= e->endframe)
+					ent->render.frame2 = -1; // disappear
+				ent->render.framelerp = frame - intframe;
+				ent->render.frame1time = e->frame1time;
+				ent->render.frame2time = e->frame2time;
 
 				// normal stuff
-				VectorCopy(e->origin, vis->render.origin);
-				vis->render.model = cl.model_precache[e->modelindex];
-				vis->render.frame = vis->render.frame2;
-				vis->render.colormap = -1; // no special coloring
-				vis->render.scale = 1;
-				vis->render.alpha = 1;
+				VectorCopy(e->origin, ent->render.origin);
+				ent->render.model = cl.model_precache[e->modelindex];
+				ent->render.frame = ent->render.frame2;
+				ent->render.colormap = -1; // no special coloring
+				ent->render.scale = 1;
+				ent->render.alpha = 1;
+
+				CL_BoundingBoxForEntity(&ent->render);
 			}
 		}
 	}
 }
 
+void CL_RelinkBeams (void)
+{
+	int i;
+	beam_t *b;
+	vec3_t dist, org;
+	float d;
+	entity_t *ent;
+	float yaw, pitch;
+	float forward;
+
+	for (i = 0, b = cl_beams;i < cl_max_beams;i++, b++)
+	{
+		if (!b->model || b->endtime < cl.time)
+			continue;
+
+		// if coming from the player, update the start position
+		//if (b->entity == cl.viewentity)
+		//	VectorCopy (cl_entities[cl.viewentity].render.origin, b->start);
+		if (b->entity && cl_entities[b->entity].state_current.active)
+		{
+			VectorCopy (cl_entities[b->entity].render.origin, b->start);
+			b->start[2] += 16;
+		}
+
+		// calculate pitch and yaw
+		VectorSubtract (b->end, b->start, dist);
+
+		if (dist[1] == 0 && dist[0] == 0)
+		{
+			yaw = 0;
+			if (dist[2] > 0)
+				pitch = 90;
+			else
+				pitch = 270;
+		}
+		else
+		{
+			yaw = (int) (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);
+			if (pitch < 0)
+				pitch += 360;
+		}
+
+		// add new entities for the lightning
+		VectorCopy (b->start, org);
+		d = VectorNormalizeLength(dist);
+		while (d > 0)
+		{
+			ent = CL_NewTempEntity ();
+			if (!ent)
+				return;
+			VectorCopy (org, ent->render.origin);
+			ent->render.model = b->model;
+			ent->render.effects = EF_FULLBRIGHT;
+			ent->render.angles[0] = pitch;
+			ent->render.angles[1] = yaw;
+			ent->render.angles[2] = rand()%360;
+			CL_BoundingBoxForEntity(&ent->render);
+			VectorMA(org, 30, dist, org);
+			d -= 30;
+		}
+	}
+}
+
+void CL_LerpPlayer(float frac)
+{
+	int i;
+	float d;
+
+	if (cl.entitydatabase.numframes && cl.viewentity == cl.playerentity)
+	{
+		cl.viewentorigin[0] = cl.viewentoriginold[0] + frac * (cl.viewentoriginnew[0] - cl.viewentoriginold[0]);
+		cl.viewentorigin[1] = cl.viewentoriginold[1] + frac * (cl.viewentoriginnew[1] - cl.viewentoriginold[1]);
+		cl.viewentorigin[2] = cl.viewentoriginold[2] + frac * (cl.viewentoriginnew[2] - cl.viewentoriginold[2]);
+	}
+	else
+		VectorCopy (cl_entities[cl.viewentity].render.origin, cl.viewentorigin);
+
+	cl.viewzoom = cl.viewzoomold + frac * (cl.viewzoomnew - cl.viewzoomold);
+
+	for (i = 0;i < 3;i++)
+		cl.velocity[i] = cl.mvelocity[1][i] + frac * (cl.mvelocity[0][i] - cl.mvelocity[1][i]);
+
+	if (cls.demoplayback)
+	{
+		// interpolate the angles
+		for (i = 0;i < 3;i++)
+		{
+			d = cl.mviewangles[0][i] - cl.mviewangles[1][i];
+			if (d > 180)
+				d -= 360;
+			else if (d < -180)
+				d += 360;
+			cl.viewangles[i] = cl.mviewangles[1][i] + frac * d;
+		}
+	}
+}
+
 void CL_RelinkEntities (void)
 {
-	CL_DecayLights ();
-	CL_LerpPlayerVelocity();
+	float frac;
+
+	// fraction from previous network update to current
+	frac = CL_LerpPoint();
+
+	CL_ClearTempEntities();
+	CL_DecayLights();
+	CL_RelinkWorld();
+	CL_RelinkStaticEntities();
 	CL_RelinkNetworkEntities();
-	TraceLine_ScanForBModels();
 	CL_RelinkEffects();
+	CL_RelinkBeams();
 	CL_MoveParticles();
-	CL_UpdateDecals();
-	CL_UpdateTEnts();
+
+	CL_LerpPlayer(frac);
 }
 
 
@@ -799,7 +983,10 @@ int CL_ReadFromServer (void)
 		Con_Printf ("\n");
 
 	r_refdef.numentities = 0;
-	if (cls.state == ca_connected && cl.worldmodel)
+	cl_num_entities = 0;
+	cl_num_brushmodel_entities = 0;
+
+	if (cls.state == ca_connected && cls.signon == SIGNONS)
 	{
 		CL_RelinkEntities ();
 
@@ -830,12 +1017,43 @@ void CL_SendCmd (void)
 	// get basic movement from keyboard
 		CL_BaseMove (&cmd);
 
+		IN_PreMove(); // OS independent code
+
 	// allow mice or other external controllers to add to the move
 		IN_Move (&cmd);
 
+		IN_PostMove(); // OS independent code
+
 	// send the unreliable message
 		CL_SendMove (&cmd);
 	}
+#ifndef NOROUTINGFIX
+	else if (cls.signon == 0 && !cls.demoplayback)
+	{
+		// LordHavoc: fix for NAT routing of netquake:
+		// bounce back a clc_nop message to the newly allocated server port,
+		// to establish a routing connection for incoming frames,
+		// the server waits for this before sending anything
+		if (realtime > cl.sendnoptime)
+		{
+			cl.sendnoptime = realtime + 3;
+			Con_DPrintf("sending clc_nop to get server's attention\n");
+			{
+				sizebuf_t buf;
+				qbyte data[128];
+				buf.maxsize = 128;
+				buf.cursize = 0;
+				buf.data = data;
+				MSG_WriteByte(&buf, clc_nop);
+				if (NET_SendUnreliableMessage (cls.netcon, &buf) == -1)
+				{
+					Con_Printf ("CL_SendCmd: lost server connection\n");
+					CL_Disconnect ();
+				}
+			}
+		}
+	}
+#endif
 
 	if (cls.demoplayback)
 	{
@@ -850,6 +1068,8 @@ void CL_SendCmd (void)
 	if (!NET_CanSendMessage (cls.netcon))
 	{
 		Con_DPrintf ("CL_WriteToServer: can't send\n");
+		if (developer.integer)
+			SZ_HexDumpToConsole(&cls.message);
 		return;
 	}
 
@@ -928,10 +1148,16 @@ CL_Init
 void CL_Init (void)
 {
 	cl_scores_mempool = Mem_AllocPool("client player info");
-
+	cl_entities_mempool = Mem_AllocPool("client entities");
 	cl_refdef_mempool = Mem_AllocPool("refdef");
+
 	memset(&r_refdef, 0, sizeof(r_refdef));
-	r_refdef.entities = Mem_Alloc(cl_refdef_mempool, sizeof(entity_render_t *) * MAX_VISEDICTS);
+	// max entities sent to renderer per frame
+	r_refdef.maxentities = MAX_EDICTS + 256 + 512;
+	r_refdef.entities = Mem_Alloc(cl_refdef_mempool, sizeof(entity_render_t *) * r_refdef.maxentities);
+	// 256k drawqueue buffer
+	r_refdef.maxdrawqueuesize = 256 * 1024;
+	r_refdef.drawqueue = Mem_Alloc(cl_refdef_mempool, r_refdef.maxdrawqueuesize);
 
 	SZ_Alloc (&cls.message, 1024, "cls.message");
 
@@ -969,7 +1195,6 @@ void CL_Init (void)
 	Cvar_RegisterVariable (&cl_itembobheight);
 
 	Cmd_AddCommand ("entities", CL_PrintEntities_f);
-	Cmd_AddCommand ("bitprofile", CL_BitProfile_f);
 	Cmd_AddCommand ("disconnect", CL_Disconnect_f);
 	Cmd_AddCommand ("record", CL_Record_f);
 	Cmd_AddCommand ("stop", CL_Stop_f);
@@ -983,11 +1208,15 @@ void CL_Init (void)
 	if (gamemode == GAME_NEHAHRA)
 		Cmd_AddCommand ("pmodel", CL_PModel_f);
 
-	Cvar_RegisterVariable(&cl_draweffects);
+	Cvar_RegisterVariable(&r_draweffects);
+	Cvar_RegisterVariable(&cl_explosions);
+	Cvar_RegisterVariable(&cl_stainmaps);
 
 	CL_Parse_Init();
 	CL_Particles_Init();
-	CL_Decals_Init();
 	CL_Screen_Init();
 	CL_CGVM_Init();
+
+	CL_Video_Init();
 }
+