+cl_locnode_t *CL_Locs_FindNearest(const vec3_t point)
+{
+ int i;
+ cl_locnode_t *loc;
+ cl_locnode_t *best;
+ vec3_t nearestpoint;
+ vec_t dist, bestdist;
+ best = NULL;
+ bestdist = 0;
+ for (loc = cl.locnodes;loc;loc = loc->next)
+ {
+ for (i = 0;i < 3;i++)
+ nearestpoint[i] = bound(loc->mins[i], point[i], loc->maxs[i]);
+ dist = VectorDistance2(nearestpoint, point);
+ if (bestdist > dist || !best)
+ {
+ bestdist = dist;
+ best = loc;
+ if (bestdist < 1)
+ break;
+ }
+ }
+ return best;
+}
+
+void CL_Locs_FindLocationName(char *buffer, size_t buffersize, vec3_t point)
+{
+ cl_locnode_t *loc;
+ loc = CL_Locs_FindNearest(point);
+ if (loc)
+ strlcpy(buffer, loc->name, buffersize);
+ else
+ dpsnprintf(buffer, buffersize, "LOC=%.0f:%.0f:%.0f", point[0], point[1], point[2]);
+}
+
+static void CL_Locs_FreeNode(cl_locnode_t *node)
+{
+ cl_locnode_t **pointer, **next;
+ for (pointer = &cl.locnodes;*pointer;pointer = next)
+ {
+ next = &(*pointer)->next;
+ if (*pointer == node)
+ {
+ *pointer = node->next;
+ Mem_Free(node);
+ return;
+ }
+ }
+ Con_Printf("CL_Locs_FreeNode: no such node! (%p)\n", (void *)node);
+}
+
+static void CL_Locs_AddNode(vec3_t mins, vec3_t maxs, const char *name)
+{
+ cl_locnode_t *node, **pointer;
+ int namelen;
+ if (!name)
+ name = "";
+ namelen = (int)strlen(name);
+ node = (cl_locnode_t *) Mem_Alloc(cls.levelmempool, sizeof(cl_locnode_t) + namelen + 1);
+ VectorSet(node->mins, min(mins[0], maxs[0]), min(mins[1], maxs[1]), min(mins[2], maxs[2]));
+ VectorSet(node->maxs, max(mins[0], maxs[0]), max(mins[1], maxs[1]), max(mins[2], maxs[2]));
+ node->name = (char *)(node + 1);
+ memcpy(node->name, name, namelen);
+ node->name[namelen] = 0;
+ // link it into the tail of the list to preserve the order
+ for (pointer = &cl.locnodes;*pointer;pointer = &(*pointer)->next)
+ ;
+ *pointer = node;
+}
+
+static void CL_Locs_Add_f(void)
+{
+ vec3_t mins, maxs;
+ if (Cmd_Argc() != 5 && Cmd_Argc() != 8)
+ {
+ Con_Printf("usage: %s x y z[ x y z] name\n", Cmd_Argv(0));
+ return;
+ }
+ mins[0] = atof(Cmd_Argv(1));
+ mins[1] = atof(Cmd_Argv(2));
+ mins[2] = atof(Cmd_Argv(3));
+ if (Cmd_Argc() == 8)
+ {
+ maxs[0] = atof(Cmd_Argv(4));
+ maxs[1] = atof(Cmd_Argv(5));
+ maxs[2] = atof(Cmd_Argv(6));
+ CL_Locs_AddNode(mins, maxs, Cmd_Argv(7));
+ }
+ else
+ CL_Locs_AddNode(mins, mins, Cmd_Argv(4));
+}
+
+static void CL_Locs_RemoveNearest_f(void)
+{
+ cl_locnode_t *loc;
+ loc = CL_Locs_FindNearest(r_refdef.view.origin);
+ if (loc)
+ CL_Locs_FreeNode(loc);
+ else
+ Con_Printf("no loc point or box found for your location\n");
+}
+
+static void CL_Locs_Clear_f(void)
+{
+ while (cl.locnodes)
+ CL_Locs_FreeNode(cl.locnodes);
+}
+
+static void CL_Locs_Save_f(void)
+{
+ cl_locnode_t *loc;
+ qfile_t *outfile;
+ char locfilename[MAX_QPATH];
+ if (!cl.locnodes)
+ {
+ Con_Printf("No loc points/boxes exist!\n");
+ return;
+ }
+ if (cls.state != ca_connected || !cl.worldmodel)
+ {
+ Con_Printf("No level loaded!\n");
+ return;
+ }
+ dpsnprintf(locfilename, sizeof(locfilename), "%s.loc", cl.worldnamenoextension);
+
+ outfile = FS_OpenRealFile(locfilename, "w", false);
+ if (!outfile)
+ return;
+ // if any boxes are used then this is a proquake-format loc file, which
+ // allows comments, so add some relevant information at the start
+ for (loc = cl.locnodes;loc;loc = loc->next)
+ if (!VectorCompare(loc->mins, loc->maxs))
+ break;
+ if (loc)
+ {
+ FS_Printf(outfile, "// %s %s saved by %s\n// x,y,z,x,y,z,\"name\"\n\n", locfilename, Sys_TimeString("%Y-%m-%d"), engineversion);
+ for (loc = cl.locnodes;loc;loc = loc->next)
+ if (VectorCompare(loc->mins, loc->maxs))
+ break;
+ if (loc)
+ Con_Printf("Warning: writing loc file containing a mixture of qizmo-style points and proquake-style boxes may not work in qizmo or proquake!\n");
+ }
+ for (loc = cl.locnodes;loc;loc = loc->next)
+ {
+ if (VectorCompare(loc->mins, loc->maxs))
+ {
+ int len;
+ const char *s;
+ const char *in = loc->name;
+ char name[MAX_INPUTLINE];
+ for (len = 0;len < (int)sizeof(name) - 1 && *in;)
+ {
+ if (*in == ' ') {s = "$loc_name_separator";in++;}
+ else if (!strncmp(in, "SSG", 3)) {s = "$loc_name_ssg";in += 3;}
+ else if (!strncmp(in, "NG", 2)) {s = "$loc_name_ng";in += 2;}
+ else if (!strncmp(in, "SNG", 3)) {s = "$loc_name_sng";in += 3;}
+ else if (!strncmp(in, "GL", 2)) {s = "$loc_name_gl";in += 2;}
+ else if (!strncmp(in, "RL", 2)) {s = "$loc_name_rl";in += 2;}
+ else if (!strncmp(in, "LG", 2)) {s = "$loc_name_lg";in += 2;}
+ else if (!strncmp(in, "GA", 2)) {s = "$loc_name_ga";in += 2;}
+ else if (!strncmp(in, "YA", 2)) {s = "$loc_name_ya";in += 2;}
+ else if (!strncmp(in, "RA", 2)) {s = "$loc_name_ra";in += 2;}
+ else if (!strncmp(in, "MEGA", 4)) {s = "$loc_name_mh";in += 4;}
+ else s = NULL;
+ if (s)
+ {
+ while (len < (int)sizeof(name) - 1 && *s)
+ name[len++] = *s++;
+ continue;
+ }
+ name[len++] = *in++;
+ }
+ name[len] = 0;
+ FS_Printf(outfile, "%.0f %.0f %.0f %s\n", loc->mins[0]*8, loc->mins[1]*8, loc->mins[2]*8, name);
+ }
+ else
+ FS_Printf(outfile, "%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,\"%s\"\n", loc->mins[0], loc->mins[1], loc->mins[2], loc->maxs[0], loc->maxs[1], loc->maxs[2], loc->name);
+ }
+ FS_Close(outfile);
+}
+
+void CL_Locs_Reload_f(void)
+{
+ int i, linenumber, limit, len;
+ const char *s;
+ char *filedata, *text, *textend, *linestart, *linetext, *lineend;
+ fs_offset_t filesize;
+ vec3_t mins, maxs;
+ char locfilename[MAX_QPATH];
+ char name[MAX_INPUTLINE];
+
+ if (cls.state != ca_connected || !cl.worldmodel)
+ {
+ Con_Printf("No level loaded!\n");
+ return;
+ }
+
+ CL_Locs_Clear_f();
+
+ // try maps/something.loc first (LordHavoc: where I think they should be)
+ dpsnprintf(locfilename, sizeof(locfilename), "%s.loc", cl.worldnamenoextension);
+ filedata = (char *)FS_LoadFile(locfilename, cls.levelmempool, false, &filesize);
+ if (!filedata)
+ {
+ // try proquake name as well (LordHavoc: I hate path mangling)
+ dpsnprintf(locfilename, sizeof(locfilename), "locs/%s.loc", cl.worldbasename);
+ filedata = (char *)FS_LoadFile(locfilename, cls.levelmempool, false, &filesize);
+ if (!filedata)
+ return;
+ }
+ text = filedata;
+ textend = filedata + filesize;
+ for (linenumber = 1;text < textend;linenumber++)
+ {
+ linestart = text;
+ for (;text < textend && *text != '\r' && *text != '\n';text++)
+ ;
+ lineend = text;
+ if (text + 1 < textend && *text == '\r' && text[1] == '\n')
+ text++;
+ if (text < textend)
+ text++;
+ // trim trailing whitespace
+ while (lineend > linestart && ISWHITESPACE(lineend[-1]))
+ lineend--;
+ // trim leading whitespace
+ while (linestart < lineend && ISWHITESPACE(*linestart))
+ linestart++;
+ // check if this is a comment
+ if (linestart + 2 <= lineend && !strncmp(linestart, "//", 2))
+ continue;
+ linetext = linestart;
+ limit = 3;
+ for (i = 0;i < limit;i++)
+ {
+ if (linetext >= lineend)
+ break;
+ // note: a missing number is interpreted as 0
+ if (i < 3)
+ mins[i] = atof(linetext);
+ else
+ maxs[i - 3] = atof(linetext);
+ // now advance past the number
+ while (linetext < lineend && !ISWHITESPACE(*linetext) && *linetext != ',')
+ linetext++;
+ // advance through whitespace
+ if (linetext < lineend)
+ {
+ if (*linetext == ',')
+ {
+ linetext++;
+ limit = 6;
+ // note: comma can be followed by whitespace
+ }
+ if (ISWHITESPACE(*linetext))
+ {
+ // skip whitespace
+ while (linetext < lineend && ISWHITESPACE(*linetext))
+ linetext++;
+ }
+ }
+ }
+ // if this is a quoted name, remove the quotes
+ if (i == 6)
+ {
+ if (linetext >= lineend || *linetext != '"')
+ continue; // proquake location names are always quoted
+ lineend--;
+ linetext++;
+ len = min(lineend - linetext, (int)sizeof(name) - 1);
+ memcpy(name, linetext, len);
+ name[len] = 0;
+ // add the box to the list
+ CL_Locs_AddNode(mins, maxs, name);
+ }
+ // if a point was parsed, it needs to be scaled down by 8 (since
+ // point-based loc files were invented by a proxy which dealt
+ // directly with quake protocol coordinates, which are *8), turn
+ // it into a box
+ else if (i == 3)
+ {
+ // interpret silly fuhquake macros
+ for (len = 0;len < (int)sizeof(name) - 1 && linetext < lineend;)
+ {
+ if (*linetext == '$')
+ {
+ if (linetext + 18 <= lineend && !strncmp(linetext, "$loc_name_separator", 19)) {s = " ";linetext += 19;}
+ else if (linetext + 13 <= lineend && !strncmp(linetext, "$loc_name_ssg", 13)) {s = "SSG";linetext += 13;}
+ else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_ng", 12)) {s = "NG";linetext += 12;}
+ else if (linetext + 13 <= lineend && !strncmp(linetext, "$loc_name_sng", 13)) {s = "SNG";linetext += 13;}
+ else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_gl", 12)) {s = "GL";linetext += 12;}
+ else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_rl", 12)) {s = "RL";linetext += 12;}
+ else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_lg", 12)) {s = "LG";linetext += 12;}
+ else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_ga", 12)) {s = "GA";linetext += 12;}
+ else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_ya", 12)) {s = "YA";linetext += 12;}
+ else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_ra", 12)) {s = "RA";linetext += 12;}
+ else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_mh", 12)) {s = "MEGA";linetext += 12;}
+ else s = NULL;
+ if (s)
+ {
+ while (len < (int)sizeof(name) - 1 && *s)
+ name[len++] = *s++;
+ continue;
+ }
+ }
+ name[len++] = *linetext++;
+ }
+ name[len] = 0;
+ // add the point to the list
+ VectorScale(mins, (1.0 / 8.0), mins);
+ CL_Locs_AddNode(mins, mins, name);
+ }
+ else
+ continue;
+ }
+}
+
+entity_t cl_meshentities[NUM_MESHENTITIES];
+dp_model_t cl_meshentitymodels[NUM_MESHENTITIES];
+const char *cl_meshentitynames[NUM_MESHENTITIES] =
+{
+ "MESH_DEBUG",
+ "MESH_CSQC_POLYGONS",
+ "MESH_PARTICLES",
+ "MESH_UI",
+};
+
+void CL_MeshEntities_Restart(void)
+{
+ int i;
+ entity_t *ent;
+ for (i = 0; i < NUM_MESHENTITIES; i++)
+ {
+ ent = cl_meshentities + i;
+ Mod_Mesh_Create(ent->render.model, cl_meshentitynames[i]);
+ }
+}
+
+void CL_MeshEntities_Init(void)
+{
+ int i;
+ entity_t *ent;
+ for (i = 0; i < NUM_MESHENTITIES; i++)
+ {
+ ent = cl_meshentities + i;
+ ent->state_current.active = true;
+ ent->render.model = cl_meshentitymodels + i;
+ ent->render.alpha = 1;
+ ent->render.flags = RENDER_SHADOW | RENDER_LIGHT;
+ ent->render.framegroupblend[0].lerp = 1;
+ ent->render.frameblend[0].lerp = 1;
+ VectorSet(ent->render.colormod, 1, 1, 1);
+ VectorSet(ent->render.glowmod, 1, 1, 1);
+ VectorSet(ent->render.custommodellight_ambient, 1, 1, 1);
+ VectorSet(ent->render.custommodellight_diffuse, 0, 0, 0);
+ VectorSet(ent->render.custommodellight_lightdir, 0, 0, 1);
+ Matrix4x4_CreateIdentity(&ent->render.matrix);
+ CL_UpdateRenderEntity(&ent->render);
+ }
+ R_RegisterModule("cl_meshentities", CL_MeshEntities_Restart, CL_MeshEntities_Restart, CL_MeshEntities_Restart, CL_MeshEntities_Restart, CL_MeshEntities_Restart);
+}
+
+void CL_MeshEntities_AddToScene(void)
+{
+ int i;
+ entity_t *ent;
+ for (i = 0; i < NUM_MESHENTITIES && r_refdef.scene.numentities < r_refdef.scene.maxentities; i++)
+ {
+ ent = cl_meshentities + i;
+ if (ent->render.model->num_surfaces == 0)
+ continue;
+ Mod_Mesh_Finalize(ent->render.model);
+ VectorCopy(ent->render.model->normalmins, ent->render.mins);
+ VectorCopy(ent->render.model->normalmaxs, ent->render.maxs);
+ r_refdef.scene.entities[r_refdef.scene.numentities++] = &ent->render;
+ }
+}
+
+void CL_MeshEntities_Reset(void)
+{
+ int i;
+ entity_t *ent;
+ for (i = 0; i < NUM_MESHENTITIES && r_refdef.scene.numentities < r_refdef.scene.maxentities; i++)
+ {
+ ent = cl_meshentities + i;
+ Mod_Mesh_Reset(ent->render.model);
+ }
+}
+
+void CL_MeshEntities_Shutdown(void)
+{
+}
+
+extern cvar_t r_overheadsprites_pushback;
+extern cvar_t r_fullbright_directed_pitch_relative;
+extern cvar_t r_fullbright_directed_pitch;
+extern cvar_t r_fullbright_directed_ambient;
+extern cvar_t r_fullbright_directed_diffuse;
+extern cvar_t r_fullbright_directed;
+extern cvar_t r_equalize_entities_minambient;
+extern cvar_t r_equalize_entities_to;
+extern cvar_t r_equalize_entities_by;
+extern cvar_t r_hdr_glowintensity;
+
+static void CL_UpdateEntityShading_GetDirectedFullbright(vec3_t ambient, vec3_t diffuse, vec3_t worldspacenormal)
+{
+ vec3_t angles;
+
+ VectorSet(ambient, r_fullbright_directed_ambient.value, r_fullbright_directed_ambient.value, r_fullbright_directed_ambient.value);
+ VectorSet(diffuse, r_fullbright_directed_diffuse.value, r_fullbright_directed_diffuse.value, r_fullbright_directed_diffuse.value);
+
+ // Use cl.viewangles and not r_refdef.view.forward here so it is the
+ // same for all stereo views, and to better handle pitches outside
+ // [-90, 90] (in_pitch_* cvars allow that).
+ VectorCopy(cl.viewangles, angles);
+ if (r_fullbright_directed_pitch_relative.integer) {
+ angles[PITCH] += r_fullbright_directed_pitch.value;
+ }
+ else {
+ angles[PITCH] = r_fullbright_directed_pitch.value;
+ }
+ AngleVectors(angles, worldspacenormal, NULL, NULL);
+ VectorNegate(worldspacenormal, worldspacenormal);
+}
+
+static void CL_UpdateEntityShading_Entity(entity_render_t *ent)
+{
+ float shadingorigin[3], f, fa, fd, fdd, a[3], c[3], dir[3];
+ int q;
+
+ for (q = 0; q < 3; q++)
+ a[q] = c[q] = dir[q] = 0;
+
+ ent->render_modellight_forced = false;
+ ent->render_rtlight_disabled = false;
+
+ // pick an appropriate value for render_modellight_origin - if this is an
+ // attachment we want to use the parent's render_modellight_origin so that
+ // shading is the same (also important for r_shadows to cast shadows in the
+ // same direction)
+ if (VectorLength2(ent->custommodellight_origin))
+ {
+ // CSQC entities always provide this (via CL_GetTagMatrix)
+ for (q = 0; q < 3; q++)
+ shadingorigin[q] = ent->custommodellight_origin[q];
+ }
+ else if (ent->entitynumber > 0 && ent->entitynumber < cl.num_entities)
+ {
+ // network entity - follow attachment chain back to a root entity,
+ int entnum = ent->entitynumber, recursion;
+ for (recursion = 32; recursion > 0; --recursion)
+ {
+ int parentnum = cl.entities[entnum].state_current.tagentity;
+ if (parentnum < 1 || parentnum >= cl.num_entities || !cl.entities_active[parentnum])
+ break;
+ entnum = parentnum;
+ }
+ // grab the root entity's origin
+ Matrix4x4_OriginFromMatrix(&cl.entities[entnum].render.matrix, shadingorigin);
+ }
+ else
+ {
+ // not a CSQC entity (which sets custommodellight_origin), not a network
+ // entity - so it's probably not attached to anything
+ Matrix4x4_OriginFromMatrix(&ent->matrix, shadingorigin);
+ }
+
+ if (!(ent->flags & RENDER_LIGHT) || r_fullbright.integer)
+ {
+ // intentionally EF_FULLBRIGHT entity
+ // the only type that is not scaled by r_refdef.scene.lightmapintensity
+ // CSQC can still provide its own customized modellight values
+ ent->render_rtlight_disabled = true;
+ ent->render_modellight_forced = true;
+ if (ent->flags & RENDER_CUSTOMIZEDMODELLIGHT)
+ {
+ // custom colors provided by CSQC
+ for (q = 0; q < 3; q++)
+ {
+ a[q] = ent->custommodellight_ambient[q];
+ c[q] = ent->custommodellight_diffuse[q];
+ dir[q] = ent->custommodellight_lightdir[q];
+ }
+ }
+ else if (r_fullbright_directed.integer)
+ CL_UpdateEntityShading_GetDirectedFullbright(a, c, dir);
+ else
+ for (q = 0; q < 3; q++)
+ a[q] = 1;
+ }
+ else
+ {
+ // fetch the lighting from the worldmodel data
+
+ // CSQC can provide its own customized modellight values
+ if (ent->flags & RENDER_CUSTOMIZEDMODELLIGHT)
+ {
+ ent->render_modellight_forced = true;
+ for (q = 0; q < 3; q++)
+ {
+ a[q] = ent->custommodellight_ambient[q];
+ c[q] = ent->custommodellight_diffuse[q];
+ dir[q] = ent->custommodellight_lightdir[q];
+ }
+ }
+ else if (ent->model->type == mod_sprite && !(ent->model->data_textures[0].basematerialflags & MATERIALFLAG_FULLBRIGHT))
+ {
+ if (ent->model->sprite.sprnum_type == SPR_OVERHEAD) // apply offset for overhead sprites
+ shadingorigin[2] = shadingorigin[2] + r_overheadsprites_pushback.value;
+ R_CompleteLightPoint(a, c, dir, shadingorigin, LP_LIGHTMAP | LP_RTWORLD | LP_DYNLIGHT, r_refdef.scene.lightmapintensity, r_refdef.scene.ambientintensity);
+ ent->render_modellight_forced = true;
+ ent->render_rtlight_disabled = true;
+ }
+ else if (r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->lit && r_refdef.scene.worldmodel->brush.LightPoint)
+ R_CompleteLightPoint(a, c, dir, shadingorigin, LP_LIGHTMAP, r_refdef.scene.lightmapintensity, r_refdef.scene.ambientintensity);
+ else if (r_fullbright_directed.integer)
+ CL_UpdateEntityShading_GetDirectedFullbright(a, c, dir);
+ else
+ R_CompleteLightPoint(a, c, dir, shadingorigin, LP_LIGHTMAP, r_refdef.scene.lightmapintensity, r_refdef.scene.ambientintensity);
+
+ if (ent->flags & RENDER_EQUALIZE)
+ {
+ // first fix up ambient lighting...
+ if (r_equalize_entities_minambient.value > 0)
+ {
+ fd = 0.299f * ent->render_modellight_diffuse[0] + 0.587f * ent->render_modellight_diffuse[1] + 0.114f * ent->render_modellight_diffuse[2];
+ if (fd > 0)
+ {
+ fa = (0.299f * ent->render_modellight_ambient[0] + 0.587f * ent->render_modellight_ambient[1] + 0.114f * ent->render_modellight_ambient[2]);
+ if (fa < r_equalize_entities_minambient.value * fd)
+ {
+ // solve:
+ // fa'/fd' = minambient
+ // fa'+0.25*fd' = fa+0.25*fd
+ // ...
+ // fa' = fd' * minambient
+ // fd'*(0.25+minambient) = fa+0.25*fd
+ // ...
+ // fd' = (fa+0.25*fd) * 1 / (0.25+minambient)
+ // fa' = (fa+0.25*fd) * minambient / (0.25+minambient)
+ // ...
+ fdd = (fa + 0.25f * fd) / (0.25f + r_equalize_entities_minambient.value);
+ f = fdd / fd; // f>0 because all this is additive; f<1 because fdd<fd because this follows from fa < r_equalize_entities_minambient.value * fd
+ for (q = 0; q < 3; q++)
+ {
+ a[q] = (1 - f)*0.25f * c[q];
+ c[q] *= f;
+ }
+ }
+ }
+ }
+
+ if (r_equalize_entities_to.value > 0 && r_equalize_entities_by.value != 0)
+ {
+ fa = 0.299f * a[0] + 0.587f * a[1] + 0.114f * a[2];
+ fd = 0.299f * c[0] + 0.587f * c[1] + 0.114f * c[2];
+ f = fa + 0.25 * fd;
+ if (f > 0)
+ {
+ // adjust brightness and saturation to target
+ float l2 = r_equalize_entities_by.value, l1 = 1 - l2;
+ for (q = 0; q < 3; q++)
+ {
+ a[q] = l1 * a[q] + l2 * (fa / f);
+ c[q] = l1 * c[q] + l2 * (fd / f);
+ }
+ }
+ }
+ }
+ }
+
+ for (q = 0; q < 3; q++)
+ {
+ ent->render_fullbright[q] = ent->colormod[q];
+ ent->render_glowmod[q] = ent->glowmod[q] * r_hdr_glowintensity.value;
+ ent->render_modellight_ambient[q] = a[q] * ent->colormod[q];
+ ent->render_modellight_diffuse[q] = c[q] * ent->colormod[q];
+ ent->render_modellight_specular[q] = c[q];
+ ent->render_modellight_lightdir[q] = dir[q];
+ ent->render_lightmap_ambient[q] = ent->colormod[q] * r_refdef.scene.ambientintensity;
+ ent->render_lightmap_diffuse[q] = ent->colormod[q] * r_refdef.scene.lightmapintensity;
+ ent->render_lightmap_specular[q] = r_refdef.scene.lightmapintensity;
+ ent->render_rtlight_diffuse[q] = ent->colormod[q];
+ ent->render_rtlight_specular[q] = 1;
+ }
+
+ // these flags disable code paths, make sure it's obvious if they're ignored by storing 0 1 2
+ if (ent->render_modellight_forced)
+ for (q = 0; q < 3; q++)
+ ent->render_lightmap_ambient[q] = ent->render_lightmap_diffuse[q] = ent->render_lightmap_specular[q] = q;
+ if (ent->render_rtlight_disabled)
+ for (q = 0; q < 3; q++)
+ ent->render_rtlight_diffuse[q] = ent->render_rtlight_specular[q] = q;
+
+ if (VectorLength2(ent->render_modellight_lightdir) == 0)
+ VectorSet(ent->render_modellight_lightdir, 0, 0, 1); // have to set SOME valid vector here
+ VectorNormalize(ent->render_modellight_lightdir);
+}
+
+
+void CL_UpdateEntityShading(void)
+{
+ int i;
+ CL_UpdateEntityShading_Entity(r_refdef.scene.worldentity);
+ for (i = 0; i < r_refdef.scene.numentities; i++)
+ CL_UpdateEntityShading_Entity(r_refdef.scene.entities[i]);
+}
+