mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2024-11-14 17:01:22 +00:00
7abdfc421e
I got tired of being disappointed that nq didn't have colored lights for the power-ups (especially when I'd waste time thinking it was a bug). The problem is that the server (progs code) specifies only DIMLIGHT (qw adds in the colors). Another problem is that the server tells us only our own stats, so the colors are disabled for multiplayer otherwise it might be confusing.
346 lines
9.3 KiB
C
346 lines
9.3 KiB
C
/*
|
|
cl_ents.c
|
|
|
|
entity parsing and management
|
|
|
|
Copyright (C) 1996-1997 Id Software, Inc.
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to:
|
|
|
|
Free Software Foundation, Inc.
|
|
59 Temple Place - Suite 330
|
|
Boston, MA 02111-1307, USA
|
|
|
|
*/
|
|
#ifdef HAVE_CONFIG_H
|
|
# include "config.h"
|
|
#endif
|
|
|
|
#include "QF/cbuf.h"
|
|
#include "QF/cmd.h"
|
|
#include "QF/console.h"
|
|
#include "QF/cvar.h"
|
|
#include "QF/input.h"
|
|
#include "QF/keys.h"
|
|
#include "QF/msg.h"
|
|
#include "QF/plist.h"
|
|
#include "QF/render.h"
|
|
#include "QF/screen.h"
|
|
#include "QF/skin.h"
|
|
#include "QF/sys.h"
|
|
#include "QF/va.h"
|
|
|
|
#include "QF/plugin/vid_render.h"
|
|
#include "QF/scene/entity.h"
|
|
#include "QF/scene/scene.h"
|
|
|
|
#include "compat.h"
|
|
|
|
#include "client/effects.h"
|
|
#include "client/temp_entities.h"
|
|
#include "client/world.h"
|
|
|
|
#include "client/chase.h"
|
|
|
|
#include "nq/include/client.h"
|
|
#include "nq/include/host.h"
|
|
#include "nq/include/host.h"
|
|
#include "nq/include/server.h"
|
|
|
|
entity_t *cl_entities[MAX_EDICTS];
|
|
double cl_msgtime[MAX_EDICTS];
|
|
static byte forcelink_bytes[SET_SIZE(MAX_EDICTS)];
|
|
#define alloc_forcelink(s) (set_bits_t *)forcelink_bytes
|
|
set_t cl_forcelink = SET_STATIC_INIT (MAX_EDICTS, alloc_forcelink);
|
|
#undef alloc_forcelink
|
|
|
|
void
|
|
CL_ClearEnts (void)
|
|
{
|
|
size_t i;
|
|
|
|
for (i = 0; i < MAX_EDICTS; i++) {
|
|
if (cl_entities[i]) {
|
|
mod_funcs->Skin_Free (cl_entities[i]->renderer.skin);
|
|
Scene_DestroyEntity (cl_world.scene, cl_entities[i]);
|
|
cl_entities[i] = 0;
|
|
}
|
|
}
|
|
|
|
// clear other arrays
|
|
i = nq_entstates.num_frames * nq_entstates.num_entities;
|
|
memset (nq_entstates.frame[0], 0, i * sizeof (entity_state_t));
|
|
memset (cl_msgtime, 0, sizeof (cl_msgtime));
|
|
set_empty (&cl_forcelink);
|
|
}
|
|
|
|
entity_t *
|
|
CL_GetEntity (int num)
|
|
{
|
|
if (!cl_entities[num]) {
|
|
cl_entities[num] = Scene_CreateEntity (cl_world.scene);
|
|
CL_Init_Entity (cl_entities[num]);
|
|
}
|
|
return cl_entities[num];
|
|
}
|
|
|
|
/*
|
|
CL_LerpPoint
|
|
|
|
Determines the fraction between the last two messages at which the
|
|
objects should be put.
|
|
*/
|
|
static float
|
|
CL_LerpPoint (void)
|
|
{
|
|
float f, frac;
|
|
|
|
f = cl.mtime[0] - cl.mtime[1];
|
|
|
|
if (!f || cl_nolerp || cls.timedemo || sv.active) {
|
|
cl.time = cl.mtime[0];
|
|
return 1;
|
|
}
|
|
|
|
if (f > 0.1) { // dropped packet, or start of demo
|
|
cl.mtime[1] = cl.mtime[0] - 0.1;
|
|
f = 0.1;
|
|
}
|
|
frac = (cl.time - cl.mtime[1]) / f;
|
|
|
|
if (frac < 0) {
|
|
if (frac < -0.01)
|
|
cl.time = cl.mtime[1];
|
|
frac = 0;
|
|
} else if (frac > 1) {
|
|
if (frac > 1.01)
|
|
cl.time = cl.mtime[0];
|
|
frac = 1;
|
|
}
|
|
|
|
return frac;
|
|
}
|
|
|
|
static void
|
|
set_entity_model (int ent_ind, int modelindex)
|
|
{
|
|
entity_t *ent = cl_entities[ent_ind];
|
|
renderer_t *renderer = &ent->renderer;
|
|
animation_t *animation = &ent->animation;
|
|
renderer->model = cl_world.models.a[modelindex];
|
|
// automatic animation (torches, etc) can be either all together
|
|
// or randomized
|
|
if (renderer->model) {
|
|
if (renderer->model->synctype == ST_RAND) {
|
|
animation->syncbase = (float) (rand () & 0x7fff) / 0x7fff;
|
|
} else {
|
|
animation->syncbase = 0.0;
|
|
}
|
|
} else {
|
|
// hack to make null model players work
|
|
SET_ADD (&cl_forcelink, ent_ind);
|
|
}
|
|
animation->nolerp = 1; // don't try to lerp when the model has changed
|
|
if (ent_ind <= cl.maxclients) {
|
|
renderer->skin = mod_funcs->Skin_SetColormap (renderer->skin, ent_ind);
|
|
}
|
|
}
|
|
|
|
void
|
|
CL_RelinkEntities (void)
|
|
{
|
|
entity_t *ent;
|
|
entity_state_t *new, *old;
|
|
renderer_t *renderer;
|
|
animation_t *animation;
|
|
float bobjrotate, frac, f;
|
|
int i, j;
|
|
int entvalid;
|
|
int model_flags;
|
|
|
|
// determine partial update time
|
|
frac = CL_LerpPoint ();
|
|
|
|
// interpolate player info
|
|
cl.viewstate.velocity = cl.frameVelocity[1]
|
|
+ frac * (cl.frameVelocity[0] - cl.frameVelocity[1]);
|
|
|
|
if (cls.demoplayback) {
|
|
// interpolate the angles
|
|
vec3_t d;
|
|
VectorSubtract (cl.frameViewAngles[0], cl.frameViewAngles[1], d);
|
|
for (j = 0; j < 3; j++) {
|
|
if (d[j] > 180) {
|
|
d[j] -= 360;
|
|
} else if (d[j] < -180) {
|
|
d[j] += 360;
|
|
}
|
|
}
|
|
VectorMultAdd (cl.frameViewAngles[1], frac, d,
|
|
cl.viewstate.player_angles);
|
|
}
|
|
|
|
bobjrotate = anglemod (100 * cl.time);
|
|
|
|
// start on the entity after the world
|
|
for (i = 1; i < cl.num_entities; i++) {
|
|
new = &nq_entstates.frame[0 + cl.frameIndex][i];
|
|
old = &nq_entstates.frame[1 - cl.frameIndex][i];
|
|
ent = CL_GetEntity (i);
|
|
renderer = &ent->renderer;
|
|
animation = &ent->animation;
|
|
|
|
// if the object wasn't included in the last packet, remove it
|
|
entvalid = cl_msgtime[i] == cl.mtime[0];
|
|
if (entvalid && !new->modelindex) {
|
|
CL_TransformEntity (ent, new->scale / 16.0, new->angles,
|
|
new->origin);
|
|
entvalid = 0;
|
|
}
|
|
if (!entvalid) {
|
|
renderer->model = NULL;
|
|
animation->pose1 = animation->pose2 = -1;
|
|
if (ent->visibility.efrag) {
|
|
R_RemoveEfrags (ent); // just became empty
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (SET_TEST_MEMBER (&cl_forcelink, i)) {
|
|
*old = *new;
|
|
}
|
|
|
|
if (SET_TEST_MEMBER (&cl_forcelink, i)
|
|
|| new->modelindex != old->modelindex) {
|
|
old->modelindex = new->modelindex;
|
|
set_entity_model (i, new->modelindex);
|
|
}
|
|
animation->frame = new->frame;
|
|
if (SET_TEST_MEMBER (&cl_forcelink, i)
|
|
|| new->colormap != old->colormap) {
|
|
old->colormap = new->colormap;
|
|
renderer->skin = mod_funcs->Skin_SetColormap (renderer->skin,
|
|
new->colormap);
|
|
}
|
|
if (SET_TEST_MEMBER (&cl_forcelink, i)
|
|
|| new->skinnum != old->skinnum) {
|
|
old->skinnum = new->skinnum;
|
|
renderer->skinnum = new->skinnum;
|
|
if (i <= cl.maxclients) {
|
|
renderer->skin = mod_funcs->Skin_SetColormap (renderer->skin,
|
|
i);
|
|
mod_funcs->Skin_SetTranslation (i, cl.players[i - 1].topcolor,
|
|
cl.players[i - 1].bottomcolor);
|
|
}
|
|
}
|
|
|
|
VectorCopy (ent_colormod[new->colormod], renderer->colormod);
|
|
renderer->colormod[3] = ENTALPHA_DECODE (new->alpha);
|
|
|
|
model_flags = 0;
|
|
if (renderer->model) {
|
|
model_flags = renderer->model->flags;
|
|
}
|
|
|
|
if (SET_TEST_MEMBER (&cl_forcelink, i)) {
|
|
// The entity was not updated in the last message so move to the
|
|
// final spot
|
|
animation->pose1 = animation->pose2 = -1;
|
|
CL_TransformEntity (ent, new->scale / 16.0, new->angles,
|
|
new->origin);
|
|
if (i != cl.viewentity || chase_active) {
|
|
if (ent->visibility.efrag) {
|
|
R_RemoveEfrags (ent);
|
|
}
|
|
R_AddEfrags (&cl_world.scene->worldmodel->brush, ent);
|
|
}
|
|
ent->old_origin = new->origin;
|
|
} else {
|
|
vec4f_t delta = new->origin - old->origin;
|
|
f = frac;
|
|
ent->old_origin = Transform_GetWorldPosition (ent->transform);
|
|
// If the delta is large, assume a teleport and don't lerp
|
|
if (fabs (delta[0]) > 100 || fabs (delta[1]) > 100
|
|
|| fabs (delta[2]) > 100) {
|
|
// assume a teleportation, not a motion
|
|
CL_TransformEntity (ent, new->scale / 16.0, new->angles,
|
|
new->origin);
|
|
animation->pose1 = animation->pose2 = -1;
|
|
} else {
|
|
// interpolate the origin and angles
|
|
vec3_t angles, d;
|
|
vec4f_t origin = old->origin + f * delta;
|
|
if (!(model_flags & EF_ROTATE)) {
|
|
VectorSubtract (new->angles, old->angles, d);
|
|
for (j = 0; j < 3; j++) {
|
|
if (d[j] > 180)
|
|
d[j] -= 360;
|
|
else if (d[j] < -180)
|
|
d[j] += 360;
|
|
}
|
|
VectorMultAdd (old->angles, f, d, angles);
|
|
}
|
|
CL_TransformEntity (ent, new->scale / 16.0, angles, origin);
|
|
}
|
|
if (i != cl.viewentity || chase_active) {
|
|
if (ent->visibility.efrag) {
|
|
vec4f_t org
|
|
= Transform_GetWorldPosition (ent->transform);
|
|
if (!VectorCompare (org, ent->old_origin)) {//FIXME
|
|
R_RemoveEfrags (ent);
|
|
R_AddEfrags (&cl_world.scene->worldmodel->brush, ent);
|
|
}
|
|
} else {
|
|
R_AddEfrags (&cl_world.scene->worldmodel->brush, ent);
|
|
}
|
|
}
|
|
}
|
|
|
|
// rotate binary objects locally
|
|
if (model_flags & EF_ROTATE) {
|
|
vec3_t angles;
|
|
VectorCopy (new->angles, angles);
|
|
angles[YAW] = bobjrotate;
|
|
CL_TransformEntity (ent, new->scale / 16.0, angles, new->origin);
|
|
}
|
|
CL_EntityEffects (i, ent, new, cl.time);
|
|
vec4f_t org = Transform_GetWorldPosition (ent->transform);
|
|
int effects = new->effects;
|
|
if (cl.maxclients == 1 && effects) {
|
|
// Enable blue and red lights for quad and invulnerability,
|
|
// but only for single-player as such information isn't provided
|
|
// by the server for other players and thus it would probably be
|
|
// confusing if the player could see the colored effects but not
|
|
// for others.
|
|
int it = cl.stats[STAT_ITEMS];
|
|
effects |= (it & IT_QUAD)
|
|
>> (BITOP_LOG2(IT_QUAD) - BITOP_LOG2 (EF_BLUE));
|
|
effects |= (it & IT_INVULNERABILITY)
|
|
>> (BITOP_LOG2(IT_INVULNERABILITY) - BITOP_LOG2 (EF_RED));
|
|
}
|
|
CL_NewDlight (i, org, effects, new->glow_size,
|
|
new->glow_color, cl.time);
|
|
if (VectorDistance_fast (old->origin, org) > (256 * 256)) {
|
|
old->origin = org;
|
|
}
|
|
if (model_flags & ~EF_ROTATE)
|
|
CL_ModelEffects (ent, i, new->glow_color, cl.time);
|
|
|
|
SET_REMOVE (&cl_forcelink, i);
|
|
}
|
|
cl.viewstate.player_entity = CL_GetEntity (cl.viewentity);
|
|
cl.viewstate.player_origin
|
|
= Transform_GetWorldPosition (cl.viewstate.player_entity->transform);
|
|
}
|