move the -1 setting of csqc_* to a better place (argh...)
[xonotic/darkplaces.git] / cl_main.c
index 136749b..7e8d834 100644 (file)
--- a/cl_main.c
+++ b/cl_main.c
@@ -21,11 +21,13 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 #include "quakedef.h"
 #include "cl_collision.h"
+#include "cl_gecko.h"
 #include "cl_video.h"
 #include "image.h"
 #include "csprogs.h"
 #include "r_shadow.h"
 #include "libcurl.h"
+#include "snd_main.h"
 
 // we need to declare some mouse variables here, because the menu system
 // references them even when on a unix system.
@@ -52,7 +54,7 @@ cvar_t m_side = {CVAR_SAVE, "m_side","0.8","mouse side speed multiplier"};
 cvar_t freelook = {CVAR_SAVE, "freelook", "1","mouse controls pitch instead of forward/back"};
 
 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", "%Y-%m-%d_%H-%M", "The format of the cl_autodemo filename, followed by the map name" };
+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"};
 
@@ -62,7 +64,7 @@ cvar_t cl_explosions_size_start = {CVAR_SAVE, "cl_explosions_size_start", "16","
 cvar_t cl_explosions_size_end = {CVAR_SAVE, "cl_explosions_size_end", "128","ending alpha of an explosion shell (just before it disappears)"};
 cvar_t cl_explosions_lifetime = {CVAR_SAVE, "cl_explosions_lifetime", "0.5","how long an explosion shell lasts"};
 
-cvar_t cl_stainmaps = {CVAR_SAVE, "cl_stainmaps", "1","stains lightmaps, much faster than decals but blurred"};
+cvar_t cl_stainmaps = {CVAR_SAVE, "cl_stainmaps", "0","stains lightmaps, much faster than decals but blurred"};
 cvar_t cl_stainmaps_clearonload = {CVAR_SAVE, "cl_stainmaps_clearonload", "1","clear stainmaps on map restart"};
 
 cvar_t cl_beams_polygons = {CVAR_SAVE, "cl_beams_polygons", "1","use beam polygons instead of models"};
@@ -87,20 +89,20 @@ cvar_t cl_locs_show = {0, "locs_show", "0", "shows defined locations for editing
 client_static_t        cls;
 client_state_t cl;
 
-#define MAX_PARTICLES                  32768   // default max # of particles at one time
-#define ABSOLUTE_MIN_PARTICLES 512             // no fewer than this no matter what's on the command line
-
 /*
 =====================
 CL_ClearState
 
 =====================
 */
+void CL_VM_ShutDown (void);
 void CL_ClearState(void)
 {
        int i;
        entity_t *ent;
 
+       CL_VM_ShutDown();
+
 // wipe the entire cl structure
        Mem_EmptyPool(cls.levelmempool);
        memset (&cl, 0, sizeof(cl));
@@ -109,31 +111,31 @@ void CL_ClearState(void)
 
        // reset the view zoom interpolation
        cl.mviewzoom[0] = cl.mviewzoom[1] = 1;
+       cl.sensitivityscale = 1.0f;
+
+       // 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;
        cl.num_brushmodel_entities = 0;
 
        // tweak these if the game runs out
        cl.max_entities = 256;
        cl.max_static_entities = 256;
-       cl.max_temp_entities = 512;
        cl.max_effects = 256;
        cl.max_beams = 256;
        cl.max_dlights = MAX_DLIGHTS;
        cl.max_lightstyle = MAX_LIGHTSTYLES;
        cl.max_brushmodel_entities = MAX_EDICTS;
-       cl.max_particles = MAX_PARTICLES;
-
-// COMMANDLINEOPTION: Client: -particles <number> changes maximum number of particles at once, default 32768
-       i = COM_CheckParm ("-particles");
-       if (i && i < com_argc - 1)
-       {
-               cl.max_particles = (int)(atoi(com_argv[i+1]));
-               if (cl.max_particles < ABSOLUTE_MIN_PARTICLES)
-                       cl.max_particles = ABSOLUTE_MIN_PARTICLES;
-       }
+       cl.max_particles = 8192; // grows dynamically
+       cl.max_decals = 2048; // grows dynamically
+       cl.max_showlmps = 0;
 
        cl.num_dlights = 0;
        cl.num_effects = 0;
@@ -142,13 +144,14 @@ void CL_ClearState(void)
        cl.entities = (entity_t *)Mem_Alloc(cls.levelmempool, cl.max_entities * sizeof(entity_t));
        cl.entities_active = (unsigned char *)Mem_Alloc(cls.levelmempool, cl.max_brushmodel_entities * sizeof(unsigned char));
        cl.static_entities = (entity_t *)Mem_Alloc(cls.levelmempool, cl.max_static_entities * sizeof(entity_t));
-       cl.temp_entities = (entity_t *)Mem_Alloc(cls.levelmempool, cl.max_temp_entities * sizeof(entity_t));
        cl.effects = (cl_effect_t *)Mem_Alloc(cls.levelmempool, cl.max_effects * sizeof(cl_effect_t));
        cl.beams = (beam_t *)Mem_Alloc(cls.levelmempool, cl.max_beams * sizeof(beam_t));
        cl.dlights = (dlight_t *)Mem_Alloc(cls.levelmempool, cl.max_dlights * sizeof(dlight_t));
        cl.lightstyle = (lightstyle_t *)Mem_Alloc(cls.levelmempool, cl.max_lightstyle * sizeof(lightstyle_t));
        cl.brushmodel_entities = (int *)Mem_Alloc(cls.levelmempool, cl.max_brushmodel_entities * sizeof(int));
        cl.particles = (particle_t *) Mem_Alloc(cls.levelmempool, cl.max_particles * sizeof(particle_t));
+       cl.decals = (decal_t *) Mem_Alloc(cls.levelmempool, cl.max_decals * sizeof(decal_t));
+       cl.showlmps = NULL;
 
        // LordHavoc: have to set up the baseline info for alpha and other stuff
        for (i = 0;i < cl.max_entities;i++)
@@ -181,7 +184,6 @@ void CL_ClearState(void)
        ent->state_current.active = true;
        ent->render.model = cl.worldmodel = NULL; // no world model yet
        ent->render.alpha = 1;
-       ent->render.colormap = -1; // no special coloring
        ent->render.flags = RENDER_SHADOW | RENDER_LIGHT;
        Matrix4x4_CreateFromQuakeEntity(&ent->render.matrix, 0, 0, 0, 0, 0, 0, 1);
        CL_UpdateRenderEntity(&ent->render);
@@ -192,6 +194,9 @@ void CL_ClearState(void)
        // mark all frames invalid for delta
        memset(cl.qw_deltasequence, -1, sizeof(cl.qw_deltasequence));
 
+       // set bestweapon data back to Quake data
+       IN_BestWeapon_ResetData();
+
        CL_Screen_NewMap();
 }
 
@@ -279,7 +284,6 @@ void CL_ExpandEntities(int num)
        }
 }
 
-void CL_VM_ShutDown (void);
 /*
 =====================
 CL_Disconnect
@@ -293,10 +297,15 @@ void CL_Disconnect(void)
        if (cls.state == ca_dedicated)
                return;
 
+       if (COM_CheckParm("-profilegameonly"))
+               Sys_AllowProfiling(false);
+
        Curl_Clear_forthismap();
 
        Con_DPrintf("CL_Disconnect\n");
 
+    Cvar_SetValueQuick(&csqc_progcrc, -1);
+       Cvar_SetValueQuick(&csqc_progsize, -1);
        CL_VM_ShutDown();
 // stop sounds (especially looping!)
        S_StopAllSounds ();
@@ -338,9 +347,9 @@ void CL_Disconnect(void)
                        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;
        }
@@ -432,17 +441,83 @@ static void CL_PrintEntities_f(void)
                        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 information on all models in the client modelindex
+===============
+*/
+static void CL_ModelIndexList_f(void)
+{
+       int i = 1;
+
+       // Print Header
+       Con_Printf("%3s: %-30s %-8s %-8s\n", "ID", "Name", "Type", "Triangles");
+
+       while(cl.model_precache[i] && i != MAX_MODELS)
+       { // Valid Model
+               if(cl.model_precache[i]->loaded || cl.model_precache[i]->isworldmodel)
+                       Con_Printf("%3i: %-30s %-8s %-10i\n", i, cl.model_precache[i]->name, cl.model_precache[i]->modeldatatypestring, cl.model_precache[i]->surfmesh.num_triangles);
+               else
+                       Con_Printf("%3i: %-30s %-30s\n", i, cl.model_precache[i]->name, "--no local model found--");
+               i++;
+       }
+}
+
+/*
+===============
+CL_SoundIndexList_f
+
+List all sounds in the client soundindex
+===============
+*/
+static void CL_SoundIndexList_f(void)
+{
+       int i = 1;
+
+       while(cl.sound_precache[i] && i != MAX_SOUNDS)
+       { // Valid Sound
+               Con_Printf("%i : %s\n", i, cl.sound_precache[i]->name);
+               i++;
        }
 }
 
+static void CL_UpdateRenderEntity_Lighting(entity_render_t *ent)
+{
+       vec3_t tempdiffusenormal;
+
+       // fetch the lighting from the worldmodel data
+       VectorSet(ent->modellight_ambient, r_refdef.scene.ambient * (2.0f / 128.0f), r_refdef.scene.ambient * (2.0f / 128.0f), r_refdef.scene.ambient * (2.0f / 128.0f));
+       VectorClear(ent->modellight_diffuse);
+       VectorClear(tempdiffusenormal);
+       if ((ent->flags & RENDER_LIGHT) && cl.worldmodel && cl.worldmodel->brush.LightPoint)
+       {
+               vec3_t org;
+               Matrix4x4_OriginFromMatrix(&ent->matrix, org);
+               cl.worldmodel->brush.LightPoint(cl.worldmodel, org, ent->modellight_ambient, ent->modellight_diffuse, tempdiffusenormal);
+       }
+       else // highly rare
+               VectorSet(ent->modellight_ambient, 1, 1, 1);
+
+       // move the light direction into modelspace coordinates for lighting code
+       Matrix4x4_Transform3x3(&ent->inversematrix, tempdiffusenormal, ent->modellight_lightdir);
+       if(VectorLength2(ent->modellight_lightdir) <= 0)
+               VectorSet(ent->modellight_lightdir, 0, 0, 1); // have to set SOME valid vector here
+       VectorNormalize(ent->modellight_lightdir);
+}
+
 //static const vec3_t nomodelmins = {-16, -16, -16};
 //static const vec3_t nomodelmaxs = {16, 16, 16};
 void CL_UpdateRenderEntity(entity_render_t *ent)
 {
        vec3_t org;
        vec_t scale;
-       model_t *model = ent->model;
+       dp_model_t *model = ent->model;
        // update the inverse matrix for the renderer
        Matrix4x4_Invert_Simple(&ent->inversematrix, &ent->matrix);
        // update the animation blend state
@@ -489,6 +564,7 @@ void CL_UpdateRenderEntity(entity_render_t *ent)
                ent->maxs[1] = org[1] + 16;
                ent->maxs[2] = org[2] + 16;
        }
+       CL_UpdateRenderEntity_Lighting(ent);
 }
 
 /*
@@ -503,7 +579,7 @@ static float CL_LerpPoint(void)
 {
        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)
@@ -519,25 +595,24 @@ static float CL_LerpPoint(void)
 
 void CL_ClearTempEntities (void)
 {
-       cl.num_temp_entities = 0;
+       r_refdef.scene.numtempentities = 0;
 }
 
-entity_t *CL_NewTempEntity(void)
+entity_render_t *CL_NewTempEntity(void)
 {
-       entity_t *ent;
+       entity_render_t *render;
 
-       if (r_refdef.numentities >= r_refdef.maxentities)
+       if (r_refdef.scene.numentities >= r_refdef.scene.maxentities)
                return NULL;
-       if (cl.num_temp_entities >= cl.max_temp_entities)
+       if (r_refdef.scene.numtempentities >= r_refdef.scene.maxtempentities)
                return NULL;
-       ent = &cl.temp_entities[cl.num_temp_entities++];
-       memset (ent, 0, sizeof(*ent));
-       r_refdef.entities[r_refdef.numentities++] = &ent->render;
+       render = &r_refdef.scene.tempentities[r_refdef.scene.numtempentities++];
+       memset (render, 0, sizeof(*render));
+       r_refdef.scene.entities[r_refdef.scene.numentities++] = render;
 
-       ent->render.colormap = -1; // no special coloring
-       ent->render.alpha = 1;
-       VectorSet(ent->render.colormod, 1, 1, 1);
-       return ent;
+       render->alpha = 1;
+       VectorSet(render->colormod, 1, 1, 1);
+       return render;
 }
 
 void CL_Effect(vec3_t org, int modelindex, int startframe, int framecount, float framerate)
@@ -581,35 +656,19 @@ void CL_AllocLightFlash(entity_render_t *ent, matrix4x4_t *matrix, float radius,
        int i;
        dlight_t *dl;
 
-       /*
-// first look for an exact key match
-       if (ent)
-       {
-               dl = cl.dlights;
-               for (i = 0;i < cl.num_dlights;i++, dl++)
-                       if (dl->ent == ent)
-                               goto dlightsetup;
-       }
-       */
-
 // then look for anything else
        dl = cl.dlights;
-       for (i = 0;i < cl.num_dlights;i++, dl++)
+       for (i = 0;i < cl.max_dlights;i++, dl++)
                if (!dl->radius)
-                       goto dlightsetup;
-       // if we hit the end of the active dlights and found no gaps, add a new one
-       if (i < MAX_DLIGHTS)
-       {
-               cl.num_dlights = i + 1;
-               goto dlightsetup;
-       }
+                       break;
 
        // unable to find one
-       return;
+       if (i == cl.max_dlights)
+               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));
+       cl.num_dlights = max(cl.num_dlights, i + 1);
        Matrix4x4_Normalize(&dl->matrix, matrix);
        dl->ent = ent;
        Matrix4x4_OriginFromMatrix(&dl->matrix, dl->origin);
@@ -685,13 +744,13 @@ void CL_RelinkLightFlashes(void)
 
        if (r_dynamic.integer)
        {
-               for (i = 0, dl = cl.dlights;i < cl.num_dlights && r_refdef.numlights < MAX_DLIGHTS;i++, dl++)
+               for (i = 0, dl = cl.dlights;i < cl.num_dlights && r_refdef.scene.numlights < MAX_DLIGHTS;i++, dl++)
                {
                        if (dl->radius)
                        {
                                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);
+                               R_RTLight_Update(&r_refdef.scene.lights[r_refdef.scene.numlights++], false, &tempmatrix, dl->color, dl->style, dl->cubemapname, dl->shadow, dl->corona, dl->coronasizescale, dl->ambientscale, dl->diffusescale, dl->specularscale, dl->flags);
                        }
                }
        }
@@ -705,21 +764,28 @@ void CL_RelinkLightFlashes(void)
        {
                if (!cl.lightstyle || !cl.lightstyle[j].length)
                {
-                       r_refdef.lightstylevalue[j] = 256;
+                       r_refdef.scene.rtlightstylevalue[j] = 1;
+                       r_refdef.scene.lightstylevalue[j] = 256;
                        continue;
                }
                k = i % cl.lightstyle[j].length;
                l = (i-1) % cl.lightstyle[j].length;
                k = cl.lightstyle[j].map[k] - 'a';
                l = cl.lightstyle[j].map[l] - 'a';
-               r_refdef.lightstylevalue[j] = (unsigned short)(((k*frac)+(l*(1-frac)))*22);
+               // rtlightstylevalue is always interpolated because it has no bad
+               // consequences for performance
+               // lightstylevalue is subject to a cvar for performance reasons;
+               // skipping lightmap updates on most rendered frames substantially
+               // improves framerates (but makes light fades look bad)
+               r_refdef.scene.rtlightstylevalue[j] = ((k*frac)+(l*(1-frac)))*(22/256.0f);
+               r_refdef.scene.lightstylevalue[j] = r_lerplightstyles.integer ? (unsigned short)(((k*frac)+(l*(1-frac)))*22) : k*22;
        }
 }
 
 void CL_AddQWCTFFlagModel(entity_t *player, int skin)
 {
        float f;
-       entity_t *flag;
+       entity_render_t *flagrender;
        matrix4x4_t flagmatrix;
 
        // this code taken from QuakeWorld
@@ -754,19 +820,18 @@ void CL_AddQWCTFFlagModel(entity_t *player, int skin)
        }
        // end of code taken from QuakeWorld
 
-       flag = CL_NewTempEntity();
-       if (!flag)
+       flagrender = CL_NewTempEntity();
+       if (!flagrender)
                return;
 
-       flag->render.model = cl.model_precache[cl.qw_modelindex_flag];
-       flag->render.skinnum = skin;
-       flag->render.colormap = -1; // no special coloring
-       flag->render.alpha = 1;
-       VectorSet(flag->render.colormod, 1, 1, 1);
+       flagrender->model = cl.model_precache[cl.qw_modelindex_flag];
+       flagrender->skinnum = skin;
+       flagrender->alpha = 1;
+       VectorSet(flagrender->colormod, 1, 1, 1);
        // attach the flag to the player matrix
        Matrix4x4_CreateFromQuakeEntity(&flagmatrix, -f, -22, 0, 0, 0, -45, 1);
-       Matrix4x4_Concat(&flag->render.matrix, &player->render.matrix, &flagmatrix);
-       CL_UpdateRenderEntity(&flag->render);
+       Matrix4x4_Concat(&flagrender->matrix, &player->render.matrix, &flagmatrix);
+       CL_UpdateRenderEntity(flagrender);
 }
 
 matrix4x4_t viewmodelmatrix;
@@ -778,15 +843,32 @@ extern void V_FadeViewFlashs(void);
 extern void V_CalcViewBlend(void);
 extern void V_CalcRefdef(void);
 
+void CL_SetEntityColormapColors(entity_render_t *ent, int colormap)
+{
+       const unsigned char *cbcolor;
+       if (colormap >= 0)
+       {
+               cbcolor = palette_rgb_pantscolormap[colormap & 0xF];
+               VectorScale(cbcolor, (1.0f / 255.0f), ent->colormap_pantscolor);
+               cbcolor = palette_rgb_shirtcolormap[(colormap & 0xF0) >> 4];
+               VectorScale(cbcolor, (1.0f / 255.0f), ent->colormap_shirtcolor);
+       }
+       else
+       {
+               VectorClear(ent->colormap_pantscolor);
+               VectorClear(ent->colormap_shirtcolor);
+       }
+}
+
 // note this is a recursive function, recursionlimit should be 32 or so on the initial call
 void CL_UpdateNetworkEntity(entity_t *e, int recursionlimit, qboolean interpolate)
 {
        const matrix4x4_t *matrix;
        matrix4x4_t blendmatrix, tempmatrix, matrix2;
-       int j, k, l;
+       int j, k, l, frame;
        float origin[3], angles[3], delta[3], lerp, d;
        entity_t *t;
-       model_t *model;
+       dp_model_t *model;
        //entity_persistent_t *p = &e->persistent;
        //entity_render_t *r = &e->render;
        // skip inactive entities and world
@@ -799,44 +881,13 @@ void CL_UpdateNetworkEntity(entity_t *e, int recursionlimit, qboolean interpolat
        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;
-               unsigned char *cbcolor;
-               e->render.colormap = e->state_current.colormap;
-               cb = (e->render.colormap & 0xF) << 4;cb += (cb >= 128 && cb < 224) ? 4 : 12;
-               cbcolor = (unsigned char *) (&palette_complete[cb]);
-               e->render.colormap_pantscolor[0] = cbcolor[0] * (1.0f / 255.0f);
-               e->render.colormap_pantscolor[1] = cbcolor[1] * (1.0f / 255.0f);
-               e->render.colormap_pantscolor[2] = cbcolor[2] * (1.0f / 255.0f);
-               cb = (e->render.colormap & 0xF0);cb += (cb >= 128 && cb < 224) ? 4 : 12;
-               cbcolor = (unsigned char *) (&palette_complete[cb]);
-               e->render.colormap_shirtcolor[0] = cbcolor[0] * (1.0f / 255.0f);
-               e->render.colormap_shirtcolor[1] = cbcolor[1] * (1.0f / 255.0f);
-               e->render.colormap_shirtcolor[2] = cbcolor[2] * (1.0f / 255.0f);
-       }
-       else if (e->state_current.colormap && cl.scores != NULL)
-       {
-               int cb;
-               unsigned char *cbcolor;
-               e->render.colormap = cl.scores[e->state_current.colormap - 1].colors; // color it
-               cb = (e->render.colormap & 0xF) << 4;cb += (cb >= 128 && cb < 224) ? 4 : 12;
-               cbcolor = (unsigned char *) (&palette_complete[cb]);
-               e->render.colormap_pantscolor[0] = cbcolor[0] * (1.0f / 255.0f);
-               e->render.colormap_pantscolor[1] = cbcolor[1] * (1.0f / 255.0f);
-               e->render.colormap_pantscolor[2] = cbcolor[2] * (1.0f / 255.0f);
-               cb = (e->render.colormap & 0xF0);cb += (cb >= 128 && cb < 224) ? 4 : 12;
-               cbcolor = (unsigned char *) (&palette_complete[cb]);
-               e->render.colormap_shirtcolor[0] = cbcolor[0] * (1.0f / 255.0f);
-               e->render.colormap_shirtcolor[1] = cbcolor[1] * (1.0f / 255.0f);
-               e->render.colormap_shirtcolor[2] = cbcolor[2] * (1.0f / 255.0f);
-       }
+               CL_SetEntityColormapColors(&e->render, e->state_current.colormap);
+       else if (e->state_current.colormap > 0 && e->state_current.colormap <= cl.maxclients && cl.scores != NULL)
+               CL_SetEntityColormapColors(&e->render, cl.scores[e->state_current.colormap-1].colors);
        else
-       {
-               e->render.colormap = -1; // no special coloring
-               VectorClear(e->render.colormap_pantscolor);
-               VectorClear(e->render.colormap_shirtcolor);
-       }
+               CL_SetEntityColormapColors(&e->render, -1);
        e->render.skinnum = e->state_current.skin;
        if (e->state_current.tagentity)
        {
@@ -878,7 +929,10 @@ void CL_UpdateNetworkEntity(entity_t *e, int recursionlimit, qboolean interpolat
        else if (e->render.flags & RENDER_VIEWMODEL)
        {
                // view-relative entity (guns and such)
-               matrix = &viewmodelmatrix;
+               if (e->render.effects & EF_NOGUNBOB)
+                       matrix = &r_refdef.view.matrix; // really attached to view
+               else
+                       matrix = &viewmodelmatrix; // attached to gun bob matrix
        }
        else
        {
@@ -896,11 +950,7 @@ void CL_UpdateNetworkEntity(entity_t *e, int recursionlimit, qboolean interpolat
                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 (!interpolate)
-                       lerp = 1;
-               VectorLerp(cl.movement_oldorigin, lerp, cl.movement_origin, origin);
+               VectorCopy(cl.movement_origin, origin);
                VectorSet(angles, 0, cl.viewangles[1], 0);
        }
        else if (interpolate && e->persistent.lerpdeltatime > 0 && (lerp = (cl.time - e->persistent.lerpstarttime) / e->persistent.lerpdeltatime) < 1)
@@ -922,21 +972,24 @@ void CL_UpdateNetworkEntity(entity_t *e, int recursionlimit, qboolean interpolat
        }
 
        // model setup and some modelflags
-       if(e->state_current.modelindex < MAX_MODELS)
+       frame = e->state_current.frame;
+       if (e->state_current.modelindex < MAX_MODELS)
                e->render.model = cl.model_precache[e->state_current.modelindex];
+       else
+               e->render.model = NULL;
        if (e->render.model)
        {
+               if (e->render.skinnum >= e->render.model->numskins)
+                       e->render.skinnum = 0;
+               if (frame >= e->render.model->numframes)
+                       frame = 0;
+               // 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);
        }
@@ -944,8 +997,15 @@ void CL_UpdateNetworkEntity(entity_t *e, int recursionlimit, qboolean interpolat
        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)
+       if (e->render.frame2 == frame)
        {
                // update frame lerp fraction
                e->render.framelerp = 1;
@@ -963,7 +1023,7 @@ void CL_UpdateNetworkEntity(entity_t *e, int recursionlimit, qboolean interpolat
                // 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 = frame;
                e->render.frame2time = cl.time;
                e->render.framelerp = 0;
        }
@@ -985,9 +1045,6 @@ void CL_UpdateNetworkEntity(entity_t *e, int recursionlimit, qboolean interpolat
                Matrix4x4_CreateFromQuakeEntity(&e->render.matrix, origin[0], origin[1], origin[2], angles[0], angles[1], angles[2], e->render.scale);
        }
 
-       // make the other useful stuff
-       CL_UpdateRenderEntity(&e->render);
-
        // tenebrae's sprites are all additive mode (weird)
        if (gamemode == GAME_TENEBRAE && e->render.model && e->render.model->type == mod_sprite)
                e->render.effects |= EF_ADDITIVE;
@@ -1005,6 +1062,9 @@ void CL_UpdateNetworkEntity(entity_t *e, int recursionlimit, qboolean interpolat
                e->render.flags |= RENDER_SHADOW;
        if (e->render.flags & RENDER_VIEWMODEL)
                e->render.flags |= RENDER_NOSELFSHADOW;
+
+       // make the other useful stuff
+       CL_UpdateRenderEntity(&e->render);
 }
 
 // creates light and trails from an entity
@@ -1028,7 +1088,7 @@ void CL_UpdateNetworkEntityTrail(entity_t *e)
        // 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)
                {
@@ -1041,40 +1101,41 @@ void CL_UpdateNetworkEntityTrail(entity_t *e)
                        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.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;
@@ -1085,6 +1146,9 @@ void CL_UpdateNetworkEntityTrail(entity_t *e)
                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);
 }
 
@@ -1189,12 +1253,12 @@ void CL_UpdateViewModel(void)
                        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;
        }
@@ -1212,12 +1276,7 @@ void CL_LinkNetworkEntity(entity_t *e)
        // 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)
@@ -1285,7 +1344,7 @@ void CL_LinkNetworkEntity(entity_t *e)
                        CL_ParticleTrail(EFFECT_EF_STARDUST, 0, origin, origin, vec3_origin, vec3_origin, NULL, 0, true, false);
        }
        // muzzleflash fades over time, and is offset a bit
-       if (e->persistent.muzzleflash > 0 && r_refdef.numlights < MAX_DLIGHTS)
+       if (e->persistent.muzzleflash > 0 && r_refdef.scene.numlights < MAX_DLIGHTS)
        {
                vec3_t v2;
                vec3_t color;
@@ -1297,27 +1356,27 @@ void CL_LinkNetworkEntity(entity_t *e)
                Matrix4x4_SetOrigin(&tempmatrix, trace.endpos[0], trace.endpos[1], trace.endpos[2]);
                Matrix4x4_Scale(&tempmatrix, 150, 1);
                VectorSet(color, e->persistent.muzzleflash * 4.0f, e->persistent.muzzleflash * 4.0f, e->persistent.muzzleflash * 4.0f);
-               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);
+               R_RTLight_Update(&r_refdef.scene.lights[r_refdef.scene.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
@@ -1326,10 +1385,10 @@ void CL_LinkNetworkEntity(entity_t *e)
                // * 4 for the expansion from 0-255 to 0-1023 range,
                // / 255 to scale down byte colors
                dlightradius = max(dlightradius, e->state_current.glowsize * 4);
-               VectorMA(dlightcolor, (1.0f / 255.0f), (unsigned char *)&palette_complete[e->state_current.glowcolor], dlightcolor);
+               VectorMA(dlightcolor, (1.0f / 255.0f), palette_rgb[e->state_current.glowcolor], dlightcolor);
        }
        // make the glow dlight
-       if (dlightradius > 0 && (dlightcolor[0] || dlightcolor[1] || dlightcolor[2]) && !(e->render.flags & RENDER_VIEWMODEL) && r_refdef.numlights < MAX_DLIGHTS)
+       if (dlightradius > 0 && (dlightcolor[0] || dlightcolor[1] || dlightcolor[2]) && !(e->render.flags & RENDER_VIEWMODEL) && r_refdef.scene.numlights < MAX_DLIGHTS)
        {
                matrix4x4_t dlightmatrix;
                Matrix4x4_Normalize(&dlightmatrix, &e->render.matrix);
@@ -1337,10 +1396,10 @@ void CL_LinkNetworkEntity(entity_t *e)
                //if (e->state_current.number == cl.viewentity/* && !chase_active.integer*/)
                //      Matrix4x4_AdjustOrigin(&dlightmatrix, 0, 0, 30);
                Matrix4x4_Scale(&dlightmatrix, dlightradius, 1);
-               R_RTLight_Update(&r_refdef.lights[r_refdef.numlights++], false, &dlightmatrix, dlightcolor, -1, NULL, true, 1, 0.25, 0, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
+               R_RTLight_Update(&r_refdef.scene.lights[r_refdef.scene.numlights++], false, &dlightmatrix, dlightcolor, -1, NULL, true, 1, 0.25, 0, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
        }
        // custom rtlight
-       if ((e->state_current.lightpflags & PFLAGS_FULLDYNAMIC) && r_refdef.numlights < MAX_DLIGHTS)
+       if ((e->state_current.lightpflags & PFLAGS_FULLDYNAMIC) && r_refdef.scene.numlights < MAX_DLIGHTS)
        {
                matrix4x4_t dlightmatrix;
                float light[4];
@@ -1353,7 +1412,7 @@ void CL_LinkNetworkEntity(entity_t *e)
                // FIXME: add ambient/diffuse/specular scales as an extension ontop of TENEBRAE_GFX_DLIGHTS?
                Matrix4x4_Normalize(&dlightmatrix, &e->render.matrix);
                Matrix4x4_Scale(&dlightmatrix, light[3], 1);
-               R_RTLight_Update(&r_refdef.lights[r_refdef.numlights++], false, &dlightmatrix, light, e->state_current.lightstyle, e->state_current.skin > 0 ? va("cubemaps/%i", e->state_current.skin) : NULL, !(e->state_current.lightpflags & PFLAGS_NOSHADOW), (e->state_current.lightpflags & PFLAGS_CORONA) != 0, 0.25, 0, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
+               R_RTLight_Update(&r_refdef.scene.lights[r_refdef.scene.numlights++], false, &dlightmatrix, light, e->state_current.lightstyle, e->state_current.skin > 0 ? va("cubemaps/%i", e->state_current.skin) : NULL, !(e->state_current.lightpflags & PFLAGS_NOSHADOW), (e->state_current.lightpflags & PFLAGS_CORONA) != 0, 0.25, 0, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
        }
        // do trail light
        if (e->render.flags & RENDER_GLOWTRAIL)
@@ -1361,10 +1420,14 @@ void CL_LinkNetworkEntity(entity_t *e)
        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)
-               r_refdef.entities[r_refdef.numentities++] = &e->render;
+       if (e->render.model && !(e->render.effects & EF_NODRAW) && r_refdef.scene.numentities < r_refdef.scene.maxentities)
+               r_refdef.scene.entities[r_refdef.scene.numentities++] = &e->render;
        //if (cl.viewentity && e->state_current.number == cl.viewentity)
        //      Matrix4x4_Print(&e->render.matrix);
 }
@@ -1374,26 +1437,25 @@ void CL_RelinkWorld(void)
        entity_t *ent = &cl.entities[0];
        // FIXME: this should be done at load
        ent->render.matrix = identitymatrix;
-       CL_UpdateRenderEntity(&ent->render);
        ent->render.flags = RENDER_SHADOW;
        if (!r_fullbright.integer)
                ent->render.flags |= RENDER_LIGHT;
        VectorSet(ent->render.colormod, 1, 1, 1);
-       r_refdef.worldentity = &ent->render;
-       r_refdef.worldmodel = cl.worldmodel;
+       CL_UpdateRenderEntity(&ent->render);
+       r_refdef.scene.worldentity = &ent->render;
+       r_refdef.scene.worldmodel = cl.worldmodel;
 }
 
 static void CL_RelinkStaticEntities(void)
 {
        int i;
        entity_t *e;
-       for (i = 0, e = cl.static_entities;i < cl.num_static_entities && r_refdef.numentities < r_refdef.maxentities;i++, e++)
+       for (i = 0, e = cl.static_entities;i < cl.num_static_entities && r_refdef.scene.numentities < r_refdef.scene.maxentities;i++, e++)
        {
                e->render.flags = 0;
                // if the model was not loaded when the static entity was created we
                // need to re-fetch the model pointer
                e->render.model = cl.model_precache[e->state_baseline.modelindex];
-               CL_UpdateRenderEntity(&e->render);
                // either fullbright or lit
                if (!(e->render.effects & EF_FULLBRIGHT) && !r_fullbright.integer)
                        e->render.flags |= RENDER_LIGHT;
@@ -1402,7 +1464,8 @@ static void CL_RelinkStaticEntities(void)
                        e->render.flags |= RENDER_SHADOW;
                VectorSet(e->render.colormod, 1, 1, 1);
                R_LerpAnimation(&e->render);
-               r_refdef.entities[r_refdef.numentities++] = &e->render;
+               CL_UpdateRenderEntity(&e->render);
+               r_refdef.scene.entities[r_refdef.scene.numentities++] = &e->render;
        }
 }
 
@@ -1434,7 +1497,7 @@ static void CL_RelinkEffects(void)
 {
        int i, intframe;
        cl_effect_t *e;
-       entity_t *ent;
+       entity_render_t *entrender;
        float frame;
 
        for (i = 0, e = cl.effects;i < cl.num_effects;i++, e++)
@@ -1460,29 +1523,27 @@ static void CL_RelinkEffects(void)
 
                        // 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()))
+                       if (r_draweffects.integer && (entrender = CL_NewTempEntity()))
                        {
                                // interpolation stuff
-                               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;
+                               entrender->frame1 = intframe;
+                               entrender->frame2 = intframe + 1;
+                               if (entrender->frame2 >= e->endframe)
+                                       entrender->frame2 = -1; // disappear
+                               entrender->framelerp = frame - intframe;
+                               entrender->frame1time = e->frame1time;
+                               entrender->frame2time = e->frame2time;
 
                                // normal stuff
                                if(e->modelindex < MAX_MODELS)
-                                       ent->render.model = cl.model_precache[e->modelindex];
+                                       entrender->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);
-
-                               Matrix4x4_CreateFromQuakeEntity(&ent->render.matrix, e->origin[0], e->origin[1], e->origin[2], 0, 0, 0, 1);
-                               CL_UpdateRenderEntity(&ent->render);
+                                       entrender->model = cl.csqc_model_precache[-(e->modelindex+1)];
+                               entrender->alpha = 1;
+                               VectorSet(entrender->colormod, 1, 1, 1);
+
+                               Matrix4x4_CreateFromQuakeEntity(&entrender->matrix, e->origin[0], e->origin[1], e->origin[2], 0, 0, 0, 1);
+                               CL_UpdateRenderEntity(entrender);
                        }
                }
        }
@@ -1516,7 +1577,7 @@ void CL_Beam_CalculatePositions(const beam_t *b, vec3_t start, vec3_t end)
                        len = VectorLength(dir);
                        VectorNormalize(dir);
                        VectorSet(localend, len, 0, 0);
-                       Matrix4x4_Transform(&r_view.matrix, localend, end);
+                       Matrix4x4_Transform(&r_refdef.view.matrix, localend, end);
                }
        }
 }
@@ -1527,8 +1588,8 @@ void CL_RelinkBeams(void)
        beam_t *b;
        vec3_t dist, org, start, end;
        float d;
-       entity_t *ent;
-       float yaw, pitch;
+       entity_render_t *entrender;
+       double yaw, pitch;
        float forward;
        matrix4x4_t tempmatrix;
 
@@ -1546,13 +1607,13 @@ void CL_RelinkBeams(void)
 
                if (b->lightning)
                {
-                       if (cl_beams_lightatend.integer && r_refdef.numlights < MAX_DLIGHTS)
+                       if (cl_beams_lightatend.integer && r_refdef.scene.numlights < MAX_DLIGHTS)
                        {
                                // FIXME: create a matrix from the beam start/end orientation
                                vec3_t dlightcolor;
                                VectorSet(dlightcolor, 0.3, 0.7, 1);
                                Matrix4x4_CreateFromQuakeEntity(&tempmatrix, end[0], end[1], end[2], 0, 0, 0, 200);
-                               R_RTLight_Update(&r_refdef.lights[r_refdef.numlights++], false, &tempmatrix, dlightcolor, -1, NULL, true, 1, 0.25, 1, 0, 0, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
+                               R_RTLight_Update(&r_refdef.scene.lights[r_refdef.scene.numlights++], false, &tempmatrix, dlightcolor, -1, NULL, true, 1, 0.25, 1, 0, 0, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
                        }
                        if (cl_beams_polygons.integer)
                                continue;
@@ -1571,12 +1632,12 @@ void CL_RelinkBeams(void)
                }
                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;
                }
@@ -1586,17 +1647,17 @@ void CL_RelinkBeams(void)
                d = VectorNormalizeLength(dist);
                while (d > 0)
                {
-                       ent = CL_NewTempEntity ();
-                       if (!ent)
+                       entrender = CL_NewTempEntity ();
+                       if (!entrender)
                                return;
                        //VectorCopy (org, ent->render.origin);
-                       ent->render.model = b->model;
+                       entrender->model = b->model;
                        //ent->render.effects = EF_FULLBRIGHT;
                        //ent->render.angles[0] = pitch;
                        //ent->render.angles[1] = yaw;
                        //ent->render.angles[2] = rand()%360;
-                       Matrix4x4_CreateFromQuakeEntity(&ent->render.matrix, org[0], org[1], org[2], -pitch, yaw, lhrandom(0, 360), 1);
-                       CL_UpdateRenderEntity(&ent->render);
+                       Matrix4x4_CreateFromQuakeEntity(&entrender->matrix, org[0], org[1], org[2], -pitch, yaw, lhrandom(0, 360), 1);
+                       CL_UpdateRenderEntity(entrender);
                        VectorMA(org, 30, dist, org);
                        d -= 30;
                }
@@ -1610,7 +1671,7 @@ static void CL_RelinkQWNails(void)
 {
        int i;
        vec_t *v;
-       entity_t *ent;
+       entity_render_t *entrender;
 
        for (i = 0;i < cl.qw_num_nails;i++)
        {
@@ -1618,17 +1679,16 @@ static void CL_RelinkQWNails(void)
 
                // if we're drawing effects, get a new temp entity
                // (NewTempEntity adds it to the render entities list for us)
-               if (!(ent = CL_NewTempEntity()))
+               if (!(entrender = CL_NewTempEntity()))
                        continue;
 
                // normal stuff
-               ent->render.model = cl.model_precache[cl.qw_modelindex_spike];
-               ent->render.colormap = -1; // no special coloring
-               ent->render.alpha = 1;
-               VectorSet(ent->render.colormod, 1, 1, 1);
+               entrender->model = cl.model_precache[cl.qw_modelindex_spike];
+               entrender->alpha = 1;
+               VectorSet(entrender->colormod, 1, 1, 1);
 
-               Matrix4x4_CreateFromQuakeEntity(&ent->render.matrix, v[0], v[1], v[2], v[3], v[4], v[5], 1);
-               CL_UpdateRenderEntity(&ent->render);
+               Matrix4x4_CreateFromQuakeEntity(&entrender->matrix, v[0], v[1], v[2], v[3], v[4], v[5], 1);
+               CL_UpdateRenderEntity(entrender);
        }
 }
 
@@ -1682,21 +1742,18 @@ void CSQC_RelinkAllEntities (int drawmask)
 
 /*
 ===============
-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;
-       r_view.matrix = identitymatrix;
+       r_refdef.scene.extraupdate = !r_speeds.integer;
+       r_refdef.scene.numentities = 0;
+       r_refdef.scene.numlights = 0;
+       r_refdef.view.matrix = identitymatrix;
+       r_refdef.view.quality = 1;
 
        cl.num_brushmodel_entities = 0;
 
@@ -1732,16 +1789,10 @@ int CL_ReadFromServer(void)
                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;
+               // decals, particles, and explosions will be updated during rneder
        }
 
-       return 0;
+       r_refdef.scene.time = cl.time;
 }
 
 // LordHavoc: pausedemo command
@@ -1763,13 +1814,26 @@ static void CL_Fog_f (void)
 {
        if (Cmd_Argc () == 1)
        {
-               Con_Printf("\"fog\" is \"%f %f %f %f\"\n", r_refdef.fog_density, r_refdef.fog_red, r_refdef.fog_green, r_refdef.fog_blue);
+               Con_Printf("\"fog\" is \"%f %f %f %f %f %f %f\"\n", r_refdef.fog_density, r_refdef.fog_red, r_refdef.fog_green, r_refdef.fog_blue, r_refdef.fog_alpha, r_refdef.fog_start, r_refdef.fog_end);
                return;
        }
-       r_refdef.fog_density = atof(Cmd_Argv(1));
-       r_refdef.fog_red = atof(Cmd_Argv(2));
-       r_refdef.fog_green = atof(Cmd_Argv(3));
-       r_refdef.fog_blue = atof(Cmd_Argv(4));
+       r_refdef.fog_start = 0;
+       r_refdef.fog_end = 16384;
+       r_refdef.fog_alpha = 1;
+       if(Cmd_Argc() > 1)
+               r_refdef.fog_density = atof(Cmd_Argv(1));
+       if(Cmd_Argc() > 2)
+               r_refdef.fog_red = atof(Cmd_Argv(2));
+       if(Cmd_Argc() > 3)
+               r_refdef.fog_green = atof(Cmd_Argv(3));
+       if(Cmd_Argc() > 4)
+               r_refdef.fog_blue = atof(Cmd_Argv(4));
+       if(Cmd_Argc() > 5)
+               r_refdef.fog_alpha = atof(Cmd_Argv(5));
+       if(Cmd_Argc() > 6)
+               r_refdef.fog_start = atof(Cmd_Argv(6));
+       if(Cmd_Argc() > 7)
+               r_refdef.fog_end = atof(Cmd_Argv(7));
 }
 
 /*
@@ -1782,21 +1846,19 @@ For program optimization
 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);
+       r_refdef.scene.extraupdate = false;
 
        timestart = Sys_DoubleTime();
        for (i = 0;i < 128;i++)
        {
-               Matrix4x4_CreateFromQuakeEntity(&r_view.matrix, r_view.origin[0], r_view.origin[1], r_view.origin[2], 0, i / 128.0 * 360.0, 0, 1);
+               Matrix4x4_CreateFromQuakeEntity(&r_refdef.view.matrix, r_refdef.view.origin[0], r_refdef.view.origin[1], r_refdef.view.origin[2], 0, i / 128.0 * 360.0, 0, 1);
+               r_refdef.view.quality = 1;
                CL_UpdateScreen();
        }
        timedelta = Sys_DoubleTime() - timestart;
 
-       VectorCopy(oldangles, cl.viewangles);
        Con_Printf("%f seconds (%f fps)\n", timedelta, 128/timedelta);
 }
 
@@ -1899,7 +1961,7 @@ void CL_Locs_Add_f(void)
 void CL_Locs_RemoveNearest_f(void)
 {
        cl_locnode_t *loc;
-       loc = CL_Locs_FindNearest(r_view.origin);
+       loc = CL_Locs_FindNearest(r_refdef.view.origin);
        if (loc)
                CL_Locs_FreeNode(loc);
        else
@@ -2131,6 +2193,7 @@ CL_Shutdown
 */
 void CL_Shutdown (void)
 {
+       CL_Screen_Shutdown();
        CL_Particles_Shutdown();
        CL_Parse_Shutdown();
 
@@ -2150,8 +2213,11 @@ void CL_Init (void)
 
        memset(&r_refdef, 0, sizeof(r_refdef));
        // max entities sent to renderer per frame
-       r_refdef.maxentities = MAX_EDICTS + 256 + 512;
-       r_refdef.entities = (entity_render_t **)Mem_Alloc(cls.permanentmempool, sizeof(entity_render_t *) * r_refdef.maxentities);
+       r_refdef.scene.maxentities = MAX_EDICTS + 256 + 512;
+       r_refdef.scene.entities = (entity_render_t **)Mem_Alloc(cls.permanentmempool, sizeof(entity_render_t *) * r_refdef.scene.maxentities);
+
+       r_refdef.scene.maxtempentities = 4096; // FIXME: make this grow
+       r_refdef.scene.tempentities = (entity_render_t *)Mem_Alloc(cls.permanentmempool, sizeof(entity_render_t) * r_refdef.scene.maxtempentities);
 
        CL_InitInput ();
 
@@ -2188,10 +2254,15 @@ void CL_Init (void)
        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");
 
+       // Support Client-side Model Index List
+       Cmd_AddCommand ("cl_modelindexlist", CL_ModelIndexList_f, "list information on all models in the client modelindex");
+       // Support Client-side Sound Index List
+       Cmd_AddCommand ("cl_soundindexlist", CL_SoundIndexList_f, "list all sounds in the client soundindex");
+
        Cvar_RegisterVariable (&cl_autodemo);
        Cvar_RegisterVariable (&cl_autodemo_nameformat);
 
-       Cmd_AddCommand ("fog", CL_Fog_f, "set global fog parameters (density red green blue)");
+       Cmd_AddCommand ("fog", CL_Fog_f, "set global fog parameters (density red green blue [alpha [mindist maxdist]])");
 
        // LordHavoc: added pausedemo
        Cmd_AddCommand ("pausedemo", CL_PauseDemo_f, "pause demo playback (can also safely pause demo recording if using QUAKE, QUAKEDP or NEHAHRAMOVIE protocol, useful for making movies)");
@@ -2237,6 +2308,7 @@ void CL_Init (void)
        CL_Screen_Init();
 
        CL_Video_Init();
+       CL_Gecko_Init();
 }