X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=cl_main.c;h=4fad1003ec56325bb0092db482fc11e62dab20a4;hp=ec4ca8b64442e207bfcb55cb01abfb05661ad9c8;hb=2075ae43356d724bae305ce8fd36ea570718b14a;hpb=221a6cb74c3a3b30b9e60247d6e42d7a6fcdebf0 diff --git a/cl_main.c b/cl_main.c index ec4ca8b6..4fad1003 100644 --- a/cl_main.c +++ b/cl_main.c @@ -171,7 +171,7 @@ void CL_ClearState(void) cl.entities[i].state_current = defaultstate; } - if (gamemode == GAME_NEXUIZ || gamemode == GAME_XONOTIC) + if (IS_NEXUIZ_DERIVED(gamemode)) { VectorSet(cl.playerstandmins, -16, -16, -24); VectorSet(cl.playerstandmaxs, 16, 16, 45); @@ -1218,7 +1218,7 @@ static void CL_UpdateNetworkEntityTrail(entity_t *e) { if (e->render.effects & EF_BRIGHTFIELD) { - if (gamemode == GAME_NEXUIZ || gamemode == GAME_XONOTIC) + if (IS_NEXUIZ_DERIVED(gamemode)) trailtype = EFFECT_TR_NEXUIZPLASMA; else CL_EntityParticles(e); @@ -1445,7 +1445,7 @@ static void CL_LinkNetworkEntity(entity_t *e) { if (e->render.effects & EF_BRIGHTFIELD) { - if (gamemode == GAME_NEXUIZ || gamemode == GAME_XONOTIC) + if (IS_NEXUIZ_DERIVED(gamemode)) trailtype = EFFECT_TR_NEXUIZPLASMA; } if (e->render.effects & EF_DIMLIGHT) @@ -1490,7 +1490,7 @@ static void CL_LinkNetworkEntity(entity_t *e) trace_t trace; matrix4x4_t tempmatrix; Matrix4x4_Transform(&e->render.matrix, muzzleflashorigin, v2); - trace = CL_TraceLine(origin, v2, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, true, false, NULL, false, false); + trace = CL_TraceLine(origin, v2, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, 0, collision_extendmovelength.value, true, false, NULL, false, false); Matrix4x4_Normalize(&tempmatrix, &e->render.matrix); Matrix4x4_SetOrigin(&tempmatrix, trace.endpos[0], trace.endpos[1], trace.endpos[2]); Matrix4x4_Scale(&tempmatrix, 150, 1); @@ -1586,6 +1586,10 @@ static void CL_RelinkWorld(void) CL_UpdateRenderEntity(&ent->render); r_refdef.scene.worldentity = &ent->render; r_refdef.scene.worldmodel = cl.worldmodel; + + // if the world is q2bsp, animate the textures + if (ent->render.model && ent->render.model->brush.isq2bsp) + ent->render.framegroupblend[0].frame = (int)(cl.time * 2.0f); } static void CL_RelinkStaticEntities(void) @@ -1772,7 +1776,10 @@ void CL_RelinkBeams(void) r_refdef.scene.lights[r_refdef.scene.numlights] = &r_refdef.scene.templights[r_refdef.scene.numlights];r_refdef.scene.numlights++; } if (cl_beams_polygons.integer) + { + CL_Beam_AddPolygons(b); continue; + } } // calculate pitch and yaw @@ -1806,12 +1813,7 @@ void CL_RelinkBeams(void) entrender = CL_NewTempEntity (0); if (!entrender) return; - //VectorCopy (org, ent->render.origin); 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(&entrender->matrix, org[0], org[1], org[2], -pitch, yaw, lhrandom(0, 360), 1); CL_UpdateRenderEntity(entrender); VectorMA(org, 30, dist, org); @@ -1883,6 +1885,7 @@ void CSQC_RelinkAllEntities (int drawmask) CL_RelinkStaticEntities(); CL_RelinkBeams(); CL_RelinkEffects(); + CL_RelinkLightFlashes(); // link stuff if (drawmask & ENTMASK_ENGINE) @@ -1895,6 +1898,8 @@ void CSQC_RelinkAllEntities (int drawmask) // update view blend V_CalcViewBlend(); + + CL_MeshEntities_AddToScene(); } /* @@ -1943,8 +1948,9 @@ void CL_UpdateWorld(void) // update the engine-based viewmodel CL_UpdateViewModel(); - CL_RelinkLightFlashes(); - CSQC_RelinkAllEntities(ENTMASK_ENGINE | ENTMASK_ENGINEVIEWMODELS); + // when csqc is loaded, it will call this in CSQC_UpdateView + if (!cl.csqc_loaded) + CSQC_RelinkAllEntities(ENTMASK_ENGINE | ENTMASK_ENGINEVIEWMODELS); // decals, particles, and explosions will be updated during rneder } @@ -2109,7 +2115,7 @@ static void CL_Locs_AddNode(vec3_t mins, vec3_t maxs, const char *name) int namelen; if (!name) name = ""; - namelen = strlen(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])); @@ -2369,6 +2375,309 @@ void CL_Locs_Reload_f(void) } } +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", +}; + +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; + ent->render.alpha = 0.999999f; // not quite 1 so that MATERIALFLAG_ALPHA is always set. + 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, 0, 0, 1); + 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); + } + 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); + } +} + +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_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 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]); +} + /* =========== CL_Shutdown @@ -2379,6 +2688,7 @@ void CL_Shutdown (void) CL_Screen_Shutdown(); CL_Particles_Shutdown(); CL_Parse_Shutdown(); + CL_MeshEntities_Shutdown(); Mem_FreePool (&cls.permanentmempool); Mem_FreePool (&cls.levelmempool); @@ -2498,6 +2808,7 @@ void CL_Init (void) CL_Parse_Init(); CL_Particles_Init(); CL_Screen_Init(); + CL_MeshEntities_Init(); CL_Video_Init(); }