diff --git a/engine/client/r_surf.c b/engine/client/r_surf.c
index aea1a2f05..ddfa10802 100644
--- a/engine/client/r_surf.c
+++ b/engine/client/r_surf.c
@@ -2735,7 +2735,7 @@ void Surf_BuildModelLightmaps (model_t *m)
 			{
 				if (lightmap_bgra && lightmap_bytes == 4)
 				{
-					for (j = 0; j < m->lightmaps.width*m->lightmaps.height; j++, dst += 4, src += 3)
+					for (j = min((m->lightdatasize-i*m->lightmaps.width*m->lightmaps.height*3)/3,m->lightmaps.width*m->lightmaps.height); j > 0; j--, dst += 4, src += 3)
 					{
 						dst[0] = src[2];
 						dst[1] = src[1];
diff --git a/engine/common/com_mesh.c b/engine/common/com_mesh.c
index 528af05cd..43c243303 100644
--- a/engine/common/com_mesh.c
+++ b/engine/common/com_mesh.c
@@ -1825,6 +1825,8 @@ qboolean Alias_GAliasBuildMesh(mesh_t *mesh, vbo_t **vbop, galiasinfo_t *inf, in
 	else
 #endif
 	{
+		//FIXME: replace most of this logic with Alias_BuildSkelLerps
+
 		frame1 = e->framestate.g[FS_REG].frame[0];
 		frame2 = e->framestate.g[FS_REG].frame[1];
 		lerp = e->framestate.g[FS_REG].lerpweight[1];	//FIXME
@@ -1860,6 +1862,15 @@ qboolean Alias_GAliasBuildMesh(mesh_t *mesh, vbo_t **vbop, galiasinfo_t *inf, in
 		g1 = &inf->ofsanimations[frame1];
 		g2 = &inf->ofsanimations[frame2];
 
+		if (!inf->numanimations || !g1->numposes || !g2->numposes)
+		{
+			Con_Printf("Invalid animation data on entity with model %s\n", e->model->name);
+			//no animation data. panic!
+			memset(mesh, 0, sizeof(*mesh));
+			*vbop = NULL;
+			return false;
+		}
+
 		if (g1 == g2)	//lerping within group is only done if not changing group
 		{
 			lerp = fg1time*g1->rate;
diff --git a/engine/common/gl_q2bsp.c b/engine/common/gl_q2bsp.c
index dc4fd9126..209a1007b 100644
--- a/engine/common/gl_q2bsp.c
+++ b/engine/common/gl_q2bsp.c
@@ -2895,6 +2895,7 @@ qboolean CModQ3_LoadRFaces (model_t *mod, qbyte *mod_base, lump_t *l)
 			out->lightmaptexturenums[sty] = -1;
 		}
 		out->lmshift = LMSHIFT_DEFAULT;
+		//fixme: determine texturemins from lightmap_origin
 		out->extents[0] = (LittleLong(in->lightmap_width)-1)<<out->lmshift;
 		out->extents[1] = (LittleLong(in->lightmap_height)-1)<<out->lmshift;
 		out->samples=NULL;
@@ -3466,6 +3467,7 @@ void CModQ3_LoadLighting (model_t *loadmodel, qbyte *mod_base, lump_t *l)
 
 	loadmodel->engineflags |= MDLF_RGBLIGHTING;
 	loadmodel->lightdata = out = ZG_Malloc(&loadmodel->memgroup, samples);
+	loadmodel->lightdatasize = samples;
 
 	//be careful here, q3bsp deluxemapping is done using interleaving. we want to unoverbright ONLY lightmaps and not deluxemaps.
 	for (m = 0; m < maps; m++)
@@ -4451,23 +4453,19 @@ void CM_InitBoxHull (void)
 	{
 		side = i&1;
 
-		// brush sides
+		//the pointers
 		s = &box_sides[i];
-		s->plane = 	box_planes + (i*2+side);
+		p = &box_planes[i];
+
+		// brush sides
+		s->plane = 	p;
 		s->surface = &nullsurface;
 
 		// planes
-		p = &box_planes[i*2];
-		p->type = i>>1;
+		p->type = ((i>=3)?i-3:i);
 		p->signbits = 0;
 		VectorClear (p->normal);
-		p->normal[i>>1] = 1;
-
-		p = &box_planes[i*2+1];
-		p->type = 3 + (i>>1);
-		p->signbits = 0;
-		VectorClear (p->normal);
-		p->normal[i>>1] = -1;
+		p->normal[p->type] = ((i>=3)?-1:1);
 	}
 }
 
@@ -4483,17 +4481,11 @@ BSP trees instead of being compared directly.
 void CM_SetTempboxSize (vec3_t mins, vec3_t maxs)
 {
 	box_planes[0].dist = maxs[0];
-	box_planes[1].dist = -maxs[0];
-	box_planes[2].dist = mins[0];
+	box_planes[1].dist = maxs[1];
+	box_planes[2].dist = maxs[2];
 	box_planes[3].dist = -mins[0];
-	box_planes[4].dist = maxs[1];
-	box_planes[5].dist = -maxs[1];
-	box_planes[6].dist = mins[1];
-	box_planes[7].dist = -mins[1];
-	box_planes[8].dist = maxs[2];
-	box_planes[9].dist = -maxs[2];
-	box_planes[10].dist = mins[2];
-	box_planes[11].dist = -mins[2];
+	box_planes[4].dist = -mins[1];
+	box_planes[5].dist = -mins[2];
 }
 
 model_t *CM_TempBoxModel(vec3_t mins, vec3_t maxs)
@@ -5837,6 +5829,12 @@ static qboolean BM_NativeTrace(model_t *model, int forcehullnum, int frame, vec3
 
 	if (contents & FTECONTENTS_BODY)
 	{
+		trace_contents = contents;
+		VectorCopy (start, trace_start);
+		VectorCopy (end, trace_end);
+		VectorCopy (mins, trace_mins);
+		VectorCopy (maxs, trace_maxs);
+
 		if (trace_mins[0] == 0 && trace_mins[1] == 0 && trace_mins[2] == 0 && trace_maxs[0] == 0 && trace_maxs[1] == 0 && trace_maxs[2] == 0)
 			trace_shape = shape_ispoint;
 		else if (capsule)
@@ -5844,12 +5842,6 @@ static qboolean BM_NativeTrace(model_t *model, int forcehullnum, int frame, vec3
 		else
 			trace_shape = shape_isbox;
 
-		trace_contents = contents;
-		VectorCopy (start, trace_start);
-		VectorCopy (end, trace_end);
-		VectorCopy (mins, trace_mins);
-		VectorCopy (maxs, trace_maxs);
-
 		CM_ClipBoxToBrush (trace_mins, trace_maxs, trace_start, trace_end, trace, &box_brush);
 	}
 
diff --git a/engine/gl/gl_alias.c b/engine/gl/gl_alias.c
index 60bd05374..382b3a805 100644
--- a/engine/gl/gl_alias.c
+++ b/engine/gl/gl_alias.c
@@ -1444,6 +1444,11 @@ void R_GAlias_DrawBatch(batch_t *batch)
 			{
 				/*needrecolour =*/ Alias_GAliasBuildMesh(&mesh, &batch->vbo, inf, surfnum, e, batch->shader->prog && batch->shader->prog->permu[PERMUTATION_SKELETAL].handle.glsl.handle);
 				batch->mesh = &meshl;
+				if (!mesh.numindexes)
+				{
+					batch->meshes = 0;	//something went screwy
+					batch->mesh = NULL;
+				}
 				return;
 			}
 		}
diff --git a/engine/gl/gl_backend.c b/engine/gl/gl_backend.c
index b0d1c8c7a..788e7afcd 100644
--- a/engine/gl/gl_backend.c
+++ b/engine/gl/gl_backend.c
@@ -3944,6 +3944,14 @@ static void DrawMeshes(void)
 		shaderstate.pendingvertexvbo = shaderstate.sourcevbo->coord.gl.vbo;
 	}
 
+#ifdef _DEBUG
+	if (!shaderstate.pendingvertexpointer && !shaderstate.pendingvertexvbo)
+	{
+		Con_Printf(CON_ERROR "pendingvertexpointer+vbo are both null! shader is %s\n", shaderstate.curshader->name);
+		return;
+	}
+#endif
+
 #ifdef FTE_TARGET_WEB
 	if (!shaderstate.pendingvertexvbo)
 		return;
@@ -4499,7 +4507,7 @@ static void GLBE_SubmitMeshesSortList(batch_t *sortlist)
 				continue;
 		}
 
-		if (bs->flags & SHADER_NODRAW)
+		if ((bs->flags & SHADER_NODRAW) || !batch->meshes)
 			continue;
 		if (bs->flags & SHADER_NODLIGHT)
 			if (shaderstate.mode == BEM_LIGHT)
diff --git a/engine/gl/gl_model.c b/engine/gl/gl_model.c
index 14479dad9..fd3bedf88 100644
--- a/engine/gl/gl_model.c
+++ b/engine/gl/gl_model.c
@@ -125,7 +125,7 @@ static void Mod_MemList_f(void)
 #ifndef SERVERONLY
 static void Mod_BatchList_f(void)
 {
-	int m, i;
+	int m, i, lm;
 	model_t *mod;
 	batch_t *batch;
 	unsigned int count;
@@ -2663,14 +2663,14 @@ void ModQ1_Batches_BuildQ1Q2Poly(model_t *mod, msurface_t *surf, builddata_t *co
 }
 
 #ifndef SERVERONLY
-static void Mod_Batches_BuildModelMeshes(model_t *mod, int maxverts, int maxindicies, void (*build)(model_t *mod, msurface_t *surf, builddata_t *bd), builddata_t *bd)
+static void Mod_Batches_BuildModelMeshes(model_t *mod, int maxverts, int maxindicies, void (*build)(model_t *mod, msurface_t *surf, builddata_t *bd), builddata_t *bd, int lmmerge)
 {
 	batch_t *batch;
 	msurface_t *surf;
 	mesh_t *mesh;
 	int numverts = 0;
 	int numindicies = 0;
-	int j;
+	int j, i;
 	int sortid;
 	int sty;
 	vbo_t vbo;
@@ -2749,6 +2749,23 @@ static void Mod_Batches_BuildModelMeshes(model_t *mod, int maxverts, int maxindi
 				mesh->vbofirstelement = 0;
 
 				build(mod, surf, bd);
+
+				if (lmmerge != 1)
+				for (sty = 0; sty < MAXRLIGHTMAPS; sty++)
+				{
+					if (surf->lightmaptexturenums[sty] >= 0)
+					{
+						if (mesh->lmst_array[sty])
+						{
+							for (i = 0; i < mesh->numvertexes; i++)
+							{
+								mesh->lmst_array[sty][i][1] += surf->lightmaptexturenums[sty] % lmmerge;
+								mesh->lmst_array[sty][i][1] /= lmmerge;
+							}
+						}
+						surf->lightmaptexturenums[sty] /= lmmerge;
+					}
+				}
 			}
 			batch->meshes = 0;
 			batch->firstmesh = 0;
@@ -2810,10 +2827,11 @@ void Mod_UpdateBatchShader_Q2 (struct batch_s *batch)
 	batch->shader = base->shader;
 }
 
+#define lmmerge(i) ((i>=0)?i/merge:i)
 /*
 batch->firstmesh is set only in and for this function, its cleared out elsewhere
 */
-static void Mod_Batches_Generate(model_t *mod)
+static int Mod_Batches_Generate(model_t *mod)
 {
 	int i;
 	msurface_t *surf;
@@ -2822,6 +2840,18 @@ static void Mod_Batches_Generate(model_t *mod)
 	batch_t *batch, *lbatch = NULL;
 	vec4_t plane;
 
+	int merge = sh_config.texture_maxsize / mod->lightmaps.height;
+	while (merge > mod->lightmaps.count)
+		merge /= 2;
+
+	if (merge < 1)//erk?
+		merge = 1;
+
+	mod->lightmaps.count = (mod->lightmaps.count+merge-1) & ~(merge-1);
+	mod->lightmaps.count /= merge;
+	mod->lightmaps.height *= merge;
+
+
 	//for each surface, find a suitable batch to insert it into.
 	//we use 'firstmesh' to avoid chucking out too many verts in a single vbo (gl2 hardware tends to have a 16bit limit)
 	for (i=0; i<mod->nummodelsurfaces; i++)
@@ -2862,13 +2892,13 @@ static void Mod_Batches_Generate(model_t *mod)
 
 		if (lbatch && (
 					lbatch->texture == surf->texinfo->texture &&
-					lbatch->lightmap[0] == surf->lightmaptexturenums[0] &&
+					lbatch->lightmap[0] == lmmerge(surf->lightmaptexturenums[0]) &&
 					Vector4Compare(plane, lbatch->plane) &&
 					lbatch->firstmesh + surf->mesh->numvertexes <= MAX_INDICIES) &&
 #if MAXRLIGHTMAPS > 1
-					lbatch->lightmap[1] == surf->lightmaptexturenums[1] &&
-					lbatch->lightmap[2] == surf->lightmaptexturenums[2] &&
-					lbatch->lightmap[3] == surf->lightmaptexturenums[3] &&
+					lbatch->lightmap[1] == lmmerge(surf->lightmaptexturenums[1]) &&
+					lbatch->lightmap[2] == lmmerge(surf->lightmaptexturenums[2]) &&
+					lbatch->lightmap[3] == lmmerge(surf->lightmaptexturenums[3]) &&
 #endif
 					lbatch->fog == surf->fog)
 			batch = lbatch;
@@ -2878,13 +2908,13 @@ static void Mod_Batches_Generate(model_t *mod)
 			{
 				if (
 							batch->texture == surf->texinfo->texture &&
-							batch->lightmap[0] == surf->lightmaptexturenums[0] &&
+							batch->lightmap[0] == lmmerge(surf->lightmaptexturenums[0]) &&
 							Vector4Compare(plane, batch->plane) &&
 							batch->firstmesh + surf->mesh->numvertexes <= MAX_INDICIES &&
 #if MAXRLIGHTMAPS > 1
-							batch->lightmap[1] == surf->lightmaptexturenums[1] &&
-							batch->lightmap[2] == surf->lightmaptexturenums[2] &&
-							batch->lightmap[3] == surf->lightmaptexturenums[3] &&
+							batch->lightmap[1] == lmmerge(surf->lightmaptexturenums[1]) &&
+							batch->lightmap[2] == lmmerge(surf->lightmaptexturenums[2]) &&
+							batch->lightmap[3] == lmmerge(surf->lightmaptexturenums[3]) &&
 #endif
 							batch->fog == surf->fog)
 					break;
@@ -2893,11 +2923,11 @@ static void Mod_Batches_Generate(model_t *mod)
 		if (!batch)
 		{
 			batch = ZG_Malloc(&mod->memgroup, sizeof(*batch));
-			batch->lightmap[0] = surf->lightmaptexturenums[0];
+			batch->lightmap[0] = lmmerge(surf->lightmaptexturenums[0]);
 #if MAXRLIGHTMAPS > 1
-			batch->lightmap[1] = surf->lightmaptexturenums[1];
-			batch->lightmap[2] = surf->lightmaptexturenums[2];
-			batch->lightmap[3] = surf->lightmaptexturenums[3];
+			batch->lightmap[1] = lmmerge(surf->lightmaptexturenums[1]);
+			batch->lightmap[2] = lmmerge(surf->lightmaptexturenums[2]);
+			batch->lightmap[3] = lmmerge(surf->lightmaptexturenums[3]);
 #endif
 			batch->texture = surf->texinfo->texture;
 			batch->shader = surf->texinfo->texture->shader;
@@ -2922,6 +2952,9 @@ static void Mod_Batches_Generate(model_t *mod)
 
 		lbatch = batch;
 	}
+
+	return merge;
+#undef lmmerge
 }
 
 void Mod_LightmapAllocInit(lmalloc_t *lmallocator, qboolean hasdeluxe, unsigned int width, unsigned int height, int firstlm)
@@ -2938,7 +2971,7 @@ void Mod_LightmapAllocDone(lmalloc_t *lmallocator, model_t *mod)
 {
 	mod->lightmaps.first = lmallocator->firstlm;
 	mod->lightmaps.count = (lmallocator->lmnum - lmallocator->firstlm);
-	if (lmallocator->allocated[0])
+	if (lmallocator->allocated[0])	//lmnum was only *COMPLETE* lightmaps that we allocated, and does not include the one we're currently building.
 		mod->lightmaps.count++;
 
 	if (lmallocator->deluxe)
@@ -3015,7 +3048,7 @@ static void Mod_LightmapAllocSurf(lmalloc_t *lmallocator, msurface_t *surf, int
 	Mod_LightmapAllocBlock (lmallocator, smax, tmax, &surf->light_s[surfstyle], &surf->light_t[surfstyle], &surf->lightmaptexturenums[surfstyle]);
 }
 
-static void Mod_Batches_SplitLightmaps(model_t *mod)
+static void Mod_Batches_SplitLightmaps(model_t *mod, int lmmerge)
 {
 	batch_t *batch;
 	batch_t *nb;
@@ -3023,14 +3056,13 @@ static void Mod_Batches_SplitLightmaps(model_t *mod)
 	msurface_t *surf;
 	int sty;
 
-
 	for (sortid = 0; sortid < SHADER_SORT_COUNT; sortid++)
 	for (batch = mod->batches[sortid]; batch != NULL; batch = batch->next)
 	{
 		surf = (msurface_t*)batch->mesh[0];
 		for (sty = 0; sty < MAXRLIGHTMAPS; sty++)
 		{
-			batch->lightmap[sty] = surf->lightmaptexturenums[sty];
+			batch->lightmap[sty] = (surf->lightmaptexturenums[sty]>=0)?surf->lightmaptexturenums[sty]/lmmerge:surf->lightmaptexturenums[sty];
 			batch->lmlightstyle[sty] = surf->styles[sty];
 		}
 
@@ -3039,7 +3071,8 @@ static void Mod_Batches_SplitLightmaps(model_t *mod)
 			surf = (msurface_t*)batch->mesh[j];
 			for (sty = 0; sty < MAXRLIGHTMAPS; sty++)
 			{
-				if (surf->lightmaptexturenums[sty] != batch->lightmap[sty] ||
+				int lm = (surf->lightmaptexturenums[sty]>=0)?surf->lightmaptexturenums[sty]/lmmerge:surf->lightmaptexturenums[sty];
+				if (lm != batch->lightmap[sty] ||
 					//fixme: we should merge later (reverted matching) surfaces into the prior batch
 					surf->styles[sty] != batch->lmlightstyle[sty] ||
 					surf->vlstyles[sty] != batch->vtlightstyle[sty])
@@ -3056,7 +3089,8 @@ static void Mod_Batches_SplitLightmaps(model_t *mod)
 				batch->maxmeshes = j;
 				for (sty = 0; sty < MAXRLIGHTMAPS; sty++)
 				{
-					nb->lightmap[sty] = surf->lightmaptexturenums[sty];
+					int lm = (surf->lightmaptexturenums[sty]>=0)?surf->lightmaptexturenums[sty]/lmmerge:surf->lightmaptexturenums[sty];
+					nb->lightmap[sty] = lm;
 					nb->lmlightstyle[sty] = surf->styles[sty];
 					nb->vtlightstyle[sty] = surf->vlstyles[sty];
 				}
@@ -3179,6 +3213,7 @@ static void Mod_Batches_Build(model_t *mod, builddata_t *bd)
 	int sortid;
 	batch_t *batch;
 	mesh_t *meshlist;
+	int merge = 1;
 
 	currentmodel = mod;
 
@@ -3208,7 +3243,7 @@ static void Mod_Batches_Build(model_t *mod, builddata_t *bd)
 	}
 
 	/*assign each mesh to a batch, generating as needed*/
-	Mod_Batches_Generate(mod);
+	merge = Mod_Batches_Generate(mod);
 
 	bmeshes = ZG_Malloc(&mod->memgroup, sizeof(*bmeshes)*mod->nummodelsurfaces*R_MAX_RECURSE);
 
@@ -3227,17 +3262,17 @@ static void Mod_Batches_Build(model_t *mod, builddata_t *bd)
 		surf->sbatch->mesh[surf->sbatch->meshes++] = (mesh_t*)surf;
 	}
 	if (bd)	//q3
-		Mod_Batches_SplitLightmaps(mod);
+		Mod_Batches_SplitLightmaps(mod, merge);
 	else
 		Mod_Batches_AllocLightmaps(mod);
 
 	if (!bd)
 	{
 		mod->lightmaps.surfstyles = 1;
-		Mod_Batches_BuildModelMeshes(mod, numverts, numindicies, ModQ1_Batches_BuildQ1Q2Poly, bd);
+		Mod_Batches_BuildModelMeshes(mod, numverts, numindicies, ModQ1_Batches_BuildQ1Q2Poly, bd, merge);
 	}
 	else
-		Mod_Batches_BuildModelMeshes(mod, numverts, numindicies, bd->buildfunc, bd);
+		Mod_Batches_BuildModelMeshes(mod, numverts, numindicies, bd->buildfunc, bd, merge);
 
 	if (BE_GenBrushModelVBO)
 		BE_GenBrushModelVBO(mod);
diff --git a/engine/gl/gl_rlight.c b/engine/gl/gl_rlight.c
index cbf7956df..da9e01edf 100644
--- a/engine/gl/gl_rlight.c
+++ b/engine/gl/gl_rlight.c
@@ -1086,24 +1086,26 @@ LIGHT SAMPLING
 mplane_t		*lightplane;
 vec3_t			lightspot;
 
+static void GLQ3_AddLatLong(qbyte latlong[2], vec3_t dir, float mag)
+{
+	float lat = (float)latlong[0] * (2 * M_PI)*(1.0 / 255.0);
+	float lng = (float)latlong[1] * (2 * M_PI)*(1.0 / 255.0);
+	dir[0] += mag * cos ( lng ) * sin ( lat );
+	dir[1] += mag * sin ( lng ) * sin ( lat );
+	dir[2] += mag * cos ( lat );
+}
+
 void GLQ3_LightGrid(model_t *mod, vec3_t point, vec3_t res_diffuse, vec3_t res_ambient, vec3_t res_dir)
 {
 	q3lightgridinfo_t *lg = (q3lightgridinfo_t *)cl.worldmodel->lightgrid;
 	int index[8];
 	int vi[3];
 	int i, j;
-	float t[8], direction_uv[3];
+	float t[8];
 	vec3_t vf, vf2;
-	vec3_t ambient, diffuse;
+	vec3_t ambient, diffuse, direction;
 
-	if (res_dir)
-	{
-		res_dir[0] = 1;
-		res_dir[1] = 1;
-		res_dir[2] = 0.1;
-	}
-
-	if (!lg || !lg->lightgrid)
+	if (!lg || (!lg->lightgrid && !lg->rbspelements) || lg->numlightgridelems < 1)
 	{
 		if(res_ambient)
 		{
@@ -1118,6 +1120,13 @@ void GLQ3_LightGrid(model_t *mod, vec3_t point, vec3_t res_diffuse, vec3_t res_a
 			res_diffuse[1] = 192;
 			res_diffuse[2] = 192;
 		}
+
+		if (res_dir)
+		{
+			res_dir[0] = 1;
+			res_dir[1] = 1;
+			res_dir[2] = 0.1;
+		}
 		return;
 	}
 
@@ -1132,73 +1141,64 @@ void GLQ3_LightGrid(model_t *mod, vec3_t point, vec3_t res_diffuse, vec3_t res_a
 		vf2[i] = 1.0f - vf[i];
 	}
 
-	index[0] = vi[2]*lg->gridBounds[3] + vi[1]*lg->gridBounds[0] + vi[0];
-	index[1] = index[0] + lg->gridBounds[0];
-	index[2] = index[0] + lg->gridBounds[3];
-	index[3] = index[2] + lg->gridBounds[0];
-
-	index[4] = index[0]+(index[0]<(lg->numlightgridelems-1));
-	index[5] = index[1]+(index[1]<(lg->numlightgridelems-1));
-	index[6] = index[2]+(index[2]<(lg->numlightgridelems-1));
-	index[7] = index[3]+(index[3]<(lg->numlightgridelems-1));
-
 	for ( i = 0; i < 8; i++ )
 	{
-		if ( index[i] < 0 || index[i] >= (lg->numlightgridelems) )
-		{
-			res_ambient[0] = 255;	//out of the map
-			res_ambient[1] = 255;
-			res_ambient[2] = 255;
+		//bound it properly
+		index[i] =	bound(0, vi[0]+((i&1)?1:0), lg->gridBounds[0]-1) * 1                 +
+					bound(0, vi[1]+((i&2)?1:0), lg->gridBounds[1]-1) * lg->gridBounds[0] +
+					bound(0, vi[2]+((i&4)?1:0), lg->gridBounds[2]-1) * lg->gridBounds[3] ;
+		t[i] =	((i&1)?vf[0]:vf2[0]) *
+				((i&2)?vf[1]:vf2[1]) *
+				((i&4)?vf[2]:vf2[2]) ;
+	}
 
-			if (res_diffuse)
+	//rbsp has a separate grid->index lookup for compression.
+	if (lg->rbspindexes)
+	{
+		for (i = 0; i < 8; i++)
+			index[i] = lg->rbspindexes[index[i]];
+	}
+
+	VectorClear(ambient);
+	VectorClear(diffuse);
+	VectorClear(direction);
+	if (lg->rbspelements)
+	{
+		for (i = 0; i < 8; i++)
+		{	//rbsp has up to 4 styles per grid element, which needs to be scaled by that style's current value
+			float tot = 0;
+			for (j = 0; j < countof(lg->rbspelements[index[i]].styles); j++)
 			{
-				res_diffuse[0] = 255;
-				res_diffuse[1] = 255;
-				res_diffuse[2] = 255;
+				qbyte st = lg->rbspelements[index[i]].styles[j];
+				if (st != 255)
+				{
+					float mag = d_lightstylevalue[st] * 1.0/255 * t[i];
+					//FIXME: cl_lightstyle[st].colours[rgb]
+					VectorMA (ambient,      mag, lg->rbspelements[index[i]].ambient[j],   ambient);
+					VectorMA (diffuse,      mag, lg->rbspelements[index[i]].diffuse[j],   diffuse);
+					tot += mag;
+				}
 			}
-			return;
+			GLQ3_AddLatLong(lg->rbspelements[index[i]].direction, direction, tot);
 		}
 	}
-
-	t[0] = vf2[0] * vf2[1] * vf2[2];
-	t[1] = vf[0] * vf2[1] * vf2[2];
-	t[2] = vf2[0] * vf[1] * vf2[2];
-	t[3] = vf[0] * vf[1] * vf2[2];
-	t[4] = vf2[0] * vf2[1] * vf[2];
-	t[5] = vf[0] * vf2[1] * vf[2];
-	t[6] = vf2[0] * vf[1] * vf[2];
-	t[7] = vf[0] * vf[1] * vf[2];
-
-	for ( j = 0; j < 3; j++ )
+	else
 	{
-		ambient[j] = 0;
-		diffuse[j] = 0;
-
-		for ( i = 0; i < 4; i++ )
+		for (i = 0; i < 8; i++)
 		{
-			ambient[j] += t[i*2] * lg->lightgrid[ index[i]].ambient[j];
-			ambient[j] += t[i*2+1] * lg->lightgrid[ index[i+4]].ambient[j];
-
-			diffuse[j] += t[i*2] * lg->lightgrid[ index[i]].diffuse[j];
-			diffuse[j] += t[i*2+1] * lg->lightgrid[ index[i+4]].diffuse[j];
-		}
-	}
-
-	for ( j = 0; j < 2; j++ )
-	{
-		direction_uv[j] = 0;
-
-		for ( i = 0; i < 4; i++ )
-		{
-			direction_uv[j] += t[i*2] * lg->lightgrid[ index[i]].direction[j];
-			direction_uv[j] += t[i*2+1] * lg->lightgrid[ index[i+4]].direction[j];
+			VectorMA (ambient,      t[i], lg->lightgrid[index[i]].ambient,   ambient);
+			VectorMA (diffuse,      t[i], lg->lightgrid[index[i]].diffuse,   diffuse);
+			GLQ3_AddLatLong(lg->lightgrid[index[i]].direction, direction, t[i]);
 		}
 
-		direction_uv[j] = anglemod ( direction_uv[j] );
+		VectorScale(ambient, d_lightstylevalue[0]/255.0, ambient);
+		VectorScale(diffuse, d_lightstylevalue[0]/255.0, diffuse);
+		//FIXME: cl_lightstyle[0].colours[rgb]
 	}
 
-	VectorScale(ambient, 4, ambient);
-	VectorScale(diffuse, 4, diffuse);
+	//q3bsp has *4 overbrighting.
+//	VectorScale(ambient, 4, ambient);
+//	VectorScale(diffuse, 4, diffuse);
 
 	/*ambient is the min level*/
 	/*diffuse is the max level*/
@@ -1206,11 +1206,7 @@ void GLQ3_LightGrid(model_t *mod, vec3_t point, vec3_t res_diffuse, vec3_t res_a
 	if (res_diffuse)
 		VectorAdd(diffuse, ambient, res_diffuse);
 	if (res_dir)
-	{
-		vec3_t right, left;
-		direction_uv[2] = 0;
-		AngleVectors(direction_uv, res_dir, right, left);
-	}
+		VectorCopy(direction, res_dir);
 }
 
 int GLRecursiveLightPoint (mnode_t *node, vec3_t start, vec3_t end)
diff --git a/engine/gl/gl_rmisc.c b/engine/gl/gl_rmisc.c
index 8a263b73d..cea7bbf6a 100644
--- a/engine/gl/gl_rmisc.c
+++ b/engine/gl/gl_rmisc.c
@@ -484,6 +484,9 @@ void GLR_TimeRefresh_f (void)
 	if (frames < 1)
 		frames = 128;
 
+	if (!r_refdef.playerview)
+		r_refdef.playerview = &cl.playerview[0];
+
 	if (finish == 2)
 	{
 		qglFinish ();
diff --git a/engine/server/svq3_game.c b/engine/server/svq3_game.c
index aef141277..f382a77b4 100644
--- a/engine/server/svq3_game.c
+++ b/engine/server/svq3_game.c
@@ -156,14 +156,18 @@ static void Q3G_UnlinkEntity(q3sharedEntity_t *ent)
 
 static model_t *Q3G_GetCModel(unsigned int modelindex)
 {
+	//0 is world
+	//1 == *1
+	//this is not how quake's precaches normally work.
+	modelindex++;
 	if ((unsigned int)modelindex < MAX_PRECACHE_MODELS)
 	{
 		if (!sv.models[modelindex])
 		{
-			if (modelindex == 0)
+			if (modelindex == 1)
 				sv.models[modelindex] = sv.world.worldmodel;
 			else
-				sv.models[modelindex] = Mod_ForName(Mod_FixName(va("*%i", modelindex), sv.modelname), MLV_WARN);
+				sv.models[modelindex] = Mod_ForName(Mod_FixName(va("*%i", modelindex-1), sv.modelname), MLV_WARN);
 		}
 
 		if (sv.models[modelindex]->loadstate == MLS_LOADING)
diff --git a/plugins/jabber/jabberclient.c b/plugins/jabber/jabberclient.c
index db20e238b..85e16fb9a 100644
--- a/plugins/jabber/jabberclient.c
+++ b/plugins/jabber/jabberclient.c
@@ -903,7 +903,7 @@ static int sasl_scramsha1_challenge(jclient_t *jcl, char *in, int inlen, char *o
 
 	SHA1_Hi(salted_password, password, strlen(password), &salt, atoi(itr.buf));
 	SHA1_HMAC(clientkey, sizeof(clientkey), "Client Key", strlen("Client Key"), salted_password, sizeof(salted_password));
-	SHA1(storedkey, sizeof(storedkey), clientkey, sizeof(clientkey));
+	SHA1(storedkey, sizeof(storedkey), clientkey, sizeof(clientkey));	//FIXME: switch the account's plain password to store this digest instead (with salt+itr).
 	SHA1_HMAC(clientsignature, sizeof(clientsignature), sigkey.buf, sigkey.len, storedkey, sizeof(storedkey));
 
 	for (i = 0; i < sizeof(proof); i++)