+entity_t cl_meshentities[NUM_MESHENTITIES];
+model_t cl_meshentitymodels[NUM_MESHENTITIES];
+const char *cl_meshentitynames[NUM_MESHENTITIES] =
+{
+ "MESH_SCENE",
+ "MESH_UI",
+};
+
+static 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]);
+ }
+}
+
+static 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;
+ Mod_Mesh_Create(ent->render.model, cl_meshentitynames[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);
+ VectorSet(ent->render.render_fullbright, 1, 1, 1);
+ VectorSet(ent->render.render_glowmod, 0, 0, 0);
+ VectorSet(ent->render.render_modellight_ambient, 1, 1, 1);
+ VectorSet(ent->render.render_modellight_diffuse, 0, 0, 0);
+ VectorSet(ent->render.render_modellight_specular, 0, 0, 0);
+ VectorSet(ent->render.render_modellight_lightdir_world, 0, 0, 1);
+ VectorSet(ent->render.render_modellight_lightdir_local, 0, 0, 1); // local doesn't matter because no diffuse/specular color
+ VectorSet(ent->render.render_lightmap_ambient, 0, 0, 0);
+ VectorSet(ent->render.render_lightmap_diffuse, 1, 1, 1);
+ VectorSet(ent->render.render_lightmap_specular, 1, 1, 1);
+ VectorSet(ent->render.render_rtlight_diffuse, 1, 1, 1);
+ VectorSet(ent->render.render_rtlight_specular, 1, 1, 1);
+
+ Matrix4x4_CreateIdentity(&ent->render.matrix);
+ CL_UpdateRenderEntity(&ent->render);
+ }
+ cl_meshentities[MESH_UI].render.flags = RENDER_NOSELFSHADOW;
+ R_RegisterModule("cl_meshentities", CL_MeshEntities_Restart, CL_MeshEntities_Restart, CL_MeshEntities_Restart, CL_MeshEntities_Restart, CL_MeshEntities_Restart);
+}
+
+void CL_MeshEntities_Scene_Clear(void)
+{
+ Mod_Mesh_Reset(CL_Mesh_Scene());
+}
+
+void CL_MeshEntities_Scene_AddRenderEntity(void)
+{
+ entity_t* ent = &cl_meshentities[MESH_SCENE];
+ r_refdef.scene.entities[r_refdef.scene.numentities++] = &ent->render;
+}
+
+void CL_MeshEntities_Scene_FinalizeRenderEntity(void)
+{
+ entity_t *ent = &cl_meshentities[MESH_SCENE];
+ Mod_Mesh_Finalize(ent->render.model);
+ VectorCopy(ent->render.model->normalmins, ent->render.mins);
+ VectorCopy(ent->render.model->normalmaxs, ent->render.maxs);
+}
+
+static 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_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], a[3], c[3], dir[3];
+ int q;
+
+ for (q = 0; q < 3; q++)
+ a[q] = c[q] = dir[q] = 0;
+
+ ent->render_lightgrid = false;
+ 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 (((ent->model && !ent->model->lit) || (ent->model == r_refdef.scene.worldmodel ? mod_q3bsp_lightgrid_world_surfaces.integer : mod_q3bsp_lightgrid_bsp_surfaces.integer))
+ && r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->lit && r_refdef.scene.worldmodel->brushq3.lightgridtexture && mod_q3bsp_lightgrid_texture.integer)
+ {
+ ent->render_lightgrid = true;
+ // no need to call R_CompleteLightPoint as we base it on render_lightmap_*
+ }
+ 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);
+ }
+
+ 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_world[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_world) == 0)
+ VectorSet(ent->render_modellight_lightdir_world, 0, 0, 1); // have to set SOME valid vector here
+ VectorNormalize(ent->render_modellight_lightdir_world);
+ // transform into local space for the entity as well
+ Matrix4x4_Transform3x3(&ent->inversematrix, ent->render_modellight_lightdir_world, ent->render_modellight_lightdir_local);
+ VectorNormalize(ent->render_modellight_lightdir_local);
+}
+
+
+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]);
+}
+
+qbool vid_opened = false;
+void CL_StartVideo(void)
+{
+ if (!vid_opened && cls.state != ca_dedicated)
+ {
+ vid_opened = true;
+#ifdef WIN32
+ // make sure we open sockets before opening video because the Windows Firewall "unblock?" dialog can screw up the graphics context on some graphics drivers
+ NetConn_UpdateSockets();
+#endif
+ VID_Start();
+ CDAudio_Startup();
+ }
+}
+
+extern cvar_t host_framerate;
+extern cvar_t host_speeds;
+
+double CL_Frame (double time)
+{
+ static double clframetime;
+ static double cl_timer = 0;
+ static double time1 = 0, time2 = 0, time3 = 0;
+ static double wait;
+ int pass1, pass2, pass3;
+
+ CL_VM_PreventInformationLeaks();
+
+ // get new key events
+ Key_EventQueue_Unblock();
+ SndSys_SendKeyEvents();
+ Sys_SendKeyEvents();
+
+ if((cl_timer += time) < 0)
+ return cl_timer;
+
+ // limit the frametime steps to no more than 100ms each
+ if (cl_timer > 0.1)
+ cl_timer = 0.1;
+
+ if (cls.state != ca_dedicated && (cl_timer > 0 || cls.timedemo || ((vid_activewindow ? cl_maxfps : cl_maxidlefps).value < 1)))
+ {
+ R_TimeReport("---");
+ Collision_Cache_NewFrame();
+ R_TimeReport("photoncache");
+#ifdef CONFIG_VIDEO_CAPTURE
+ // decide the simulation time
+ if (cls.capturevideo.active)
+ {
+ //***
+ if (cls.capturevideo.realtime)
+ clframetime = cl.realframetime = max(time, 1.0 / cls.capturevideo.framerate);
+ else
+ {
+ clframetime = 1.0 / cls.capturevideo.framerate;
+ cl.realframetime = max(time, clframetime);
+ }
+ }
+ else if (vid_activewindow && cl_maxfps.value >= 1 && !cls.timedemo)
+
+#else
+ if (vid_activewindow && cl_maxfps.value >= 1 && !cls.timedemo)
+#endif
+ {
+ clframetime = cl.realframetime = max(cl_timer, 1.0 / cl_maxfps.value);
+ // when running slow, we need to sleep to keep input responsive
+ wait = bound(0, cl_maxfps_alwayssleep.value * 1000, 100000);
+ if (wait > 0)
+ Sys_Sleep((int)wait);
+ }
+ else if (!vid_activewindow && cl_maxidlefps.value >= 1 && !cls.timedemo)
+ clframetime = cl.realframetime = max(cl_timer, 1.0 / cl_maxidlefps.value);
+ else
+ clframetime = cl.realframetime = cl_timer;
+
+ // apply slowmo scaling
+ clframetime *= cl.movevars_timescale;
+ // scale playback speed of demos by slowmo cvar
+ if (cls.demoplayback)
+ {
+ clframetime *= host_timescale.value;
+ // if demo playback is paused, don't advance time at all
+ if (cls.demopaused)
+ clframetime = 0;
+ }
+ else
+ {
+ // host_framerate overrides all else
+ if (host_framerate.value)
+ clframetime = host_framerate.value;
+
+ if (cl.paused || host.paused)
+ clframetime = 0;
+ }
+
+ if (cls.timedemo)
+ clframetime = cl.realframetime = cl_timer;
+
+ // deduct the frame time from the accumulator
+ cl_timer -= cl.realframetime;
+
+ cl.oldtime = cl.time;
+ cl.time += clframetime;
+
+ // update video
+ if (host_speeds.integer)
+ time1 = Sys_DirtyTime();
+ R_TimeReport("pre-input");
+
+ // Collect input into cmd
+ CL_Input();
+
+ R_TimeReport("input");
+
+ // check for new packets
+ NetConn_ClientFrame();
+
+ // read a new frame from a demo if needed
+ CL_ReadDemoMessage();
+ R_TimeReport("clientnetwork");
+
+ // now that packets have been read, send input to server
+ CL_SendMove();
+ R_TimeReport("sendmove");
+
+ // update client world (interpolate entities, create trails, etc)
+ CL_UpdateWorld();
+ R_TimeReport("lerpworld");
+
+ CL_Video_Frame();
+
+ R_TimeReport("client");
+
+ CL_UpdateScreen();
+ R_TimeReport("render");
+
+ if (host_speeds.integer)
+ time2 = Sys_DirtyTime();
+
+ // update audio
+ if(cl.csqc_usecsqclistener)
+ {
+ S_Update(&cl.csqc_listenermatrix);
+ cl.csqc_usecsqclistener = false;
+ }
+ else
+ S_Update(&r_refdef.view.matrix);
+
+ CDAudio_Update();
+ R_TimeReport("audio");
+
+ // reset gathering of mouse input
+ in_mouse_x = in_mouse_y = 0;
+
+ if (host_speeds.integer)
+ {
+ pass1 = (int)((time1 - time3)*1000000);
+ time3 = Sys_DirtyTime();
+ pass2 = (int)((time2 - time1)*1000000);
+ pass3 = (int)((time3 - time2)*1000000);
+ Con_Printf("%6ius total %6ius server %6ius gfx %6ius snd\n",
+ pass1+pass2+pass3, pass1, pass2, pass3);
+ }
+ }
+ // if there is some time remaining from this frame, reset the timer
+ return cl_timer >= 0 ? 0 : cl_timer;
+}
+