qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-11 15:51:36 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/qw/source/cl_ents.c

586 lines
16 KiB
C
Raw Normal View History

initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
/*
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
re-arrange things so __attribute__ and __builtin_expect are properly autoconfiscated so rcsid will continue to work with gcc 3.3
2003-01-15 15:31:36 +00:00
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
no header includes cvar.h now
2001-05-31 03:41:35 +00:00
#include "QF/cvar.h"
reduce gl_rmain's dependency on cl*.h
2001-05-21 00:22:35 +00:00
#include "QF/msg.h"
#include "QF/render.h"
sw_ralias.c and gl_rmain.c are now client clean. this involved a bit of a revamp of skins. keep an eye out for broken skins (especially in nq)
2001-05-21 22:25:35 +00:00
#include "QF/skin.h"
nuke Con_Printf and Con_DPrintf and use Sys_* instead
2007-11-06 10:17:14 +00:00
#include "QF/sys.h"
reduce gl_rmain's dependency on cl*.h
2001-05-21 00:22:35 +00:00
[scene] Rename libQFentity to libQFscene And start working on scene management.
2021-07-24 05:19:52 +00:00
#include "QF/scene/entity.h"
sw32. Flee in terror. This'll break compilation for everything until -sdl32 compiles. sw32 wont work for a while either, so don't get overly excited yet.
2001-08-25 02:47:11 +00:00
#include "compat.h"
[build] Move to non-recursive make There's still some cleanup to do, but everything seems to be working nicely: `make -j` works, `make distcheck` passes. There is probably plenty of bitrot in the package directories (RPM, debian), though. The vc project files have been removed since those versions are way out of date and quakeforge is pretty much dependent on gcc now anyway. Most of the old Makefile.am files are now Makemodule.am. This should allow for new Makefile.am files that allow local building (to be added on an as-needed bases). The current remaining Makefile.am files are for standalone sub-projects.a The installable bins are currently built in the top-level build directory. This may change if the clutter gets to be too much. While this does make a noticeable difference in build times, the main reason for the switch was to take care of the growing dependency issues: now it's possible to build tools for code generation (eg, using qfcc and ruamoko programs for code-gen).
2020-06-21 14:15:17 +00:00
[client] Merge nq/qw entity effects code
2021-03-11 02:25:04 +00:00
#include "client/effects.h"
[client] Move qw's loc code into client This makes the location code available to nq (not used yet) but more importantly moves some definitely client-side code into the right place.
2021-03-11 02:38:33 +00:00
#include "client/locs.h"
[client] Merge nq and qw temp entity handling This finally gets cl_tent merged away.
2021-03-10 09:00:16 +00:00
#include "client/temp_entities.h"
Move and clean up clview.h Redundant or dead prototypes deleted, and the client/view.h seems a good place for the file.
2021-03-12 02:48:53 +00:00
#include "client/view.h"
[renderer] Support multiple entity queues While there's currently only the one still, this will allow the entities to be multiply queued for multi-pass rendering (eg, shadows). As the avoidance of putting an entity in the same queue more than once relies on the entity id, all entities now come from the scene (which is stored in cl_world in the client code for nq and qw), thus the extensive changes in the clients.
2022-03-04 16:48:10 +00:00
#include "client/world.h"
[client] Merge nq and qw temp entity handling This finally gets cl_tent merged away.
2021-03-10 09:00:16 +00:00
[build] Move to non-recursive make There's still some cleanup to do, but everything seems to be working nicely: `make -j` works, `make distcheck` passes. There is probably plenty of bitrot in the package directories (RPM, debian), though. The vc project files have been removed since those versions are way out of date and quakeforge is pretty much dependent on gcc now anyway. Most of the old Makefile.am files are now Makemodule.am. This should allow for new Makefile.am files that allow local building (to be added on an as-needed bases). The current remaining Makefile.am files are for standalone sub-projects.a The installable bins are currently built in the top-level build directory. This may change if the clutter gets to be too much. While this does make a noticeable difference in build times, the main reason for the switch was to take care of the growing dependency issues: now it's possible to build tools for code generation (eg, using qfcc and ruamoko programs for code-gen).
2020-06-21 14:15:17 +00:00
#include "qw/bothdefs.h"
#include "qw/msg_ucmd.h"
proxy now stays connected :) also gets the server data packet. most changes due to move of pmove.h
2005-05-02 04:09:15 +00:00
#include "qw/pmove.h"
[build] Move to non-recursive make There's still some cleanup to do, but everything seems to be working nicely: `make -j` works, `make distcheck` passes. There is probably plenty of bitrot in the package directories (RPM, debian), though. The vc project files have been removed since those versions are way out of date and quakeforge is pretty much dependent on gcc now anyway. Most of the old Makefile.am files are now Makemodule.am. This should allow for new Makefile.am files that allow local building (to be added on an as-needed bases). The current remaining Makefile.am files are for standalone sub-projects.a The installable bins are currently built in the top-level build directory. This may change if the clutter gets to be too much. While this does make a noticeable difference in build times, the main reason for the switch was to take care of the growing dependency issues: now it's possible to build tools for code generation (eg, using qfcc and ruamoko programs for code-gen).
2020-06-21 14:15:17 +00:00
#include "qw/include/cl_cam.h"
#include "qw/include/cl_ents.h"
#include "qw/include/cl_main.h"
#include "qw/include/cl_parse.h"
#include "qw/include/cl_pred.h"
#include "qw/include/host.h"
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
entity_t cl_flag_ents[MAX_CLIENTS];
entity_t cl_entities[512]; // FIXME: magic number
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
byte cl_entity_valid[2][512];
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
void
A bit more diff reduction before attempting to merge client code.
2011-08-27 01:25:41 +00:00
CL_ClearEnts (void)
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
{
A bit more diff reduction before attempting to merge client code.
2011-08-27 01:25:41 +00:00
size_t i;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
[renderer] Support multiple entity queues While there's currently only the one still, this will allow the entities to be multiply queued for multi-pass rendering (eg, shadows). As the avoidance of putting an entity in the same queue more than once relies on the entity id, all entities now come from the scene (which is stored in cl_world in the client code for nq and qw), thus the extensive changes in the clients.
2022-03-04 16:48:10 +00:00
for (i = 0; i < MAX_CLIENTS; i++) {
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
if (Entity_Valid (cl_flag_ents[i])) {
[renderer] Support multiple entity queues While there's currently only the one still, this will allow the entities to be multiply queued for multi-pass rendering (eg, shadows). As the avoidance of putting an entity in the same queue more than once relies on the entity id, all entities now come from the scene (which is stored in cl_world in the client code for nq and qw), thus the extensive changes in the clients.
2022-03-04 16:48:10 +00:00
Scene_DestroyEntity (cl_world.scene, cl_flag_ents[i]);
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
cl_flag_ents[i] = nullentity;
[renderer] Support multiple entity queues While there's currently only the one still, this will allow the entities to be multiply queued for multi-pass rendering (eg, shadows). As the avoidance of putting an entity in the same queue more than once relies on the entity id, all entities now come from the scene (which is stored in cl_world in the client code for nq and qw), thus the extensive changes in the clients.
2022-03-04 16:48:10 +00:00
}
}
for (i = 0; i < 512; i++) {
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
if (Entity_Valid (cl_entities[i])) {
[renderer] Support multiple entity queues While there's currently only the one still, this will allow the entities to be multiply queued for multi-pass rendering (eg, shadows). As the avoidance of putting an entity in the same queue more than once relies on the entity id, all entities now come from the scene (which is stored in cl_world in the client code for nq and qw), thus the extensive changes in the clients.
2022-03-04 16:48:10 +00:00
Scene_DestroyEntity (cl_world.scene, cl_entities[i]);
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
cl_entities[i] = nullentity;
[renderer] Support multiple entity queues While there's currently only the one still, this will allow the entities to be multiply queued for multi-pass rendering (eg, shadows). As the avoidance of putting an entity in the same queue more than once relies on the entity id, all entities now come from the scene (which is stored in cl_world in the client code for nq and qw), thus the extensive changes in the clients.
2022-03-04 16:48:10 +00:00
}
}
Make nq and qw use the new entity state struct. This isn't really the best solution, but it does get things being shared with the minimum of fuss.
2012-07-01 02:36:47 +00:00
i = qw_entstates.num_frames * qw_entstates.num_entities;
memset (qw_entstates.frame[0], 0, i * sizeof (entity_state_t));
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
memset (cl_entity_valid, 0, sizeof (cl_entity_valid));
[renderer] Support multiple entity queues While there's currently only the one still, this will allow the entities to be multiply queued for multi-pass rendering (eg, shadows). As the avoidance of putting an entity in the same queue more than once relies on the entity id, all entities now come from the scene (which is stored in cl_world in the client code for nq and qw), thus the extensive changes in the clients.
2022-03-04 16:48:10 +00:00
}
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
entity_t
[renderer] Support multiple entity queues While there's currently only the one still, this will allow the entities to be multiply queued for multi-pass rendering (eg, shadows). As the avoidance of putting an entity in the same queue more than once relies on the entity id, all entities now come from the scene (which is stored in cl_world in the client code for nq and qw), thus the extensive changes in the clients.
2022-03-04 16:48:10 +00:00
CL_GetEntity (int num)
{
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
if (!Entity_Valid (cl_entities[num])) {
[renderer] Support multiple entity queues While there's currently only the one still, this will allow the entities to be multiply queued for multi-pass rendering (eg, shadows). As the avoidance of putting an entity in the same queue more than once relies on the entity id, all entities now come from the scene (which is stored in cl_world in the client code for nq and qw), thus the extensive changes in the clients.
2022-03-04 16:48:10 +00:00
cl_entities[num] = Scene_CreateEntity (cl_world.scene);
CL_Init_Entity (cl_entities[num]);
}
return cl_entities[num];
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
static entity_t
[qw] Fix carried flag handling I guess some of the earlier entity/scene handling hadn't been tested for flags as no entity was ever being created for a flag. This fixes a segfault when another player carrying a flag is potentially visible. Also make the -16 Z offset local. It looks better than global, and the global was quite wrong anyway as it was incorrectly updating W (which caused me to spend way too long figuring out why positions were breaking). There are still issues with flag handling, and things are likely to change with the ECS updates, but at least this lets me test.
2022-10-22 03:42:32 +00:00
CL_GetFlagEnt (int key)
{
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
if (!Entity_Valid (cl_flag_ents[key])) {
[qw] Fix carried flag handling I guess some of the earlier entity/scene handling hadn't been tested for flags as no entity was ever being created for a flag. This fixes a segfault when another player carrying a flag is potentially visible. Also make the -16 Z offset local. It looks better than global, and the global was quite wrong anyway as it was incorrectly updating W (which caused me to spend way too long figuring out why positions were breaking). There are still issues with flag handling, and things are likely to change with the ECS updates, but at least this lets me test.
2022-10-22 03:42:32 +00:00
cl_flag_ents[key] = Scene_CreateEntity (cl_world.scene);
CL_Init_Entity (cl_flag_ents[key]);
}
return cl_flag_ents[key];
}
Use efrags with packet entities. This fixes brush models in the software renderers.
2010-12-03 05:10:53 +00:00
// Hack hack hack
static inline int
is_dead_body (entity_state_t *s1)
{
int i = s1->frame;
if (s1->modelindex == cl_playerindex
&& (i == 49 || i == 60 || i == 69 || i == 84 || i == 93 || i == 102))
return 1;
return 0;
}
// Hack hack hack
static inline int
is_gib (entity_state_t *s1)
{
if (s1->modelindex == cl_h_playerindex || s1->modelindex == cl_gib1index
|| s1->modelindex == cl_gib2index || s1->modelindex == cl_gib3index)
return 1;
return 0;
}
make gcc more anal about prototypes, string constants and function visibility (ie, global functions must have a prototype)
2003-01-06 18:28:13 +00:00
static void
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
set_entity_model (entity_t ent, int modelindex)
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
{
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
renderer_t *renderer = Ent_GetComponent (ent.id, scene_renderer,
cl_world.scene->reg);
animation_t *animation = Ent_GetComponent (ent.id, scene_animation,
cl_world.scene->reg);
[renderer] Support multiple entity queues While there's currently only the one still, this will allow the entities to be multiply queued for multi-pass rendering (eg, shadows). As the avoidance of putting an entity in the same queue more than once relies on the entity id, all entities now come from the scene (which is stored in cl_world in the client code for nq and qw), thus the extensive changes in the clients.
2022-03-04 16:48:10 +00:00
renderer->model = cl_world.models.a[modelindex];
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
// automatic animation (torches, etc) can be either all together
// or randomized
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
if (renderer->model) {
if (renderer->model->synctype == ST_RAND) {
animation->syncbase = (float) (rand () & 0x7fff) / 0x7fff;
} else {
animation->syncbase = 0.0;
}
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
}
[client] Merge nq/qw entity effects code
2021-03-11 02:25:04 +00:00
animation->nolerp = 1; // don't try to lerp when the model has changed
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
}
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
static void
CL_LinkPacketEntities (void)
{
int i, j, forcelink;
float frac, f;
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
entity_t ent;
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
entity_state_t *new, *old;
frac = 1;
[renderer] Support multiple entity queues While there's currently only the one still, this will allow the entities to be multiply queued for multi-pass rendering (eg, shadows). As the avoidance of putting an entity in the same queue more than once relies on the entity id, all entities now come from the scene (which is stored in cl_world in the client code for nq and qw), thus the extensive changes in the clients.
2022-03-04 16:48:10 +00:00
for (i = MAX_CLIENTS + 1; i < 512; i++) {
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
new = &qw_entstates.frame[cl.link_sequence & UPDATE_MASK][i];
old = &qw_entstates.frame[cl.prev_sequence & UPDATE_MASK][i];
[renderer] Support multiple entity queues While there's currently only the one still, this will allow the entities to be multiply queued for multi-pass rendering (eg, shadows). As the avoidance of putting an entity in the same queue more than once relies on the entity id, all entities now come from the scene (which is stored in cl_world in the client code for nq and qw), thus the extensive changes in the clients.
2022-03-04 16:48:10 +00:00
ent = CL_GetEntity (i);
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
transform_t transform = Entity_Transform (ent);
renderer_t *renderer = Ent_GetComponent (ent.id, scene_renderer,
cl_world.scene->reg);
animation_t *animation = Ent_GetComponent (ent.id, scene_animation,
cl_world.scene->reg);
visibility_t *visibility = Ent_GetComponent (ent.id, scene_visibility,
cl_world.scene->reg);
vec4f_t *old_origin = Ent_GetComponent (ent.id, scene_old_origin,
cl_world.scene->reg);
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
forcelink = cl_entity_valid[0][i] != cl_entity_valid[1][i];
cl_entity_valid[1][i] = cl_entity_valid[0][i];
// if the object wasn't included in the last packet, remove it
if (!cl_entity_valid[0][i]) {
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
renderer->model = NULL;
animation->pose1 = animation->pose2 = -1;
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
if (visibility->efrag) {
[renderer] Move some functions from plugins to main lib One step in cleaning up vid_render_funcs.
2022-03-07 04:40:04 +00:00
R_RemoveEfrags (ent); // just became empty
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
}
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
continue;
}
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
// spawn light flashes, even ones coming from invisible objects
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
CL_NewDlight (i, new->origin, new->effects, new->glow_size,
[client] Merge nq/qw entity effects code
2021-03-11 02:25:04 +00:00
new->glow_color, cl.time);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
Use efrags with packet entities. This fixes brush models in the software renderers.
2010-12-03 05:10:53 +00:00
// if set to invisible, skip
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
if (!new->modelindex
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
|| (cl_deadbodyfilter && is_dead_body (new))
|| (cl_gibfilter && is_gib (new))) {
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
if (visibility->efrag) {
[renderer] Move some functions from plugins to main lib One step in cleaning up vid_render_funcs.
2022-03-07 04:40:04 +00:00
R_RemoveEfrags (ent);
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
}
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
continue;
Use efrags with packet entities. This fixes brush models in the software renderers.
2010-12-03 05:10:53 +00:00
}
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
if (forcelink)
*old = *new;
if (forcelink || new->modelindex != old->modelindex) {
old->modelindex = new->modelindex;
set_entity_model (ent, new->modelindex);
}
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
animation->frame = new->frame;
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
if (forcelink || new->colormap != old->colormap
|| new->skinnum != old->skinnum) {
old->skinnum = new->skinnum;
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
renderer->skinnum = new->skinnum;
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
old->colormap = new->colormap;
if (new->colormap && (new->colormap <= MAX_CLIENTS)
&& cl.players[new->colormap - 1].name
Add DL_LIBS to the -x11 targets. Something is funny with Ubuntu such that -ldl needs to be specifically added even though QFutil's .la specifies it. I don't know if it's a libtool issue or not, but this does work. More will probably be necessary, but this was sufficient to get prover to the point where qfcc segged building qwaq (0.7.2).
2013-02-14 00:54:36 +00:00
&& cl.players[new->colormap - 1].name->value[0]
&& new->modelindex == cl_playerindex) {
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
player_info_t *player = &cl.players[new->colormap - 1];
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
renderer->skin
= mod_funcs->Skin_SetSkin (renderer->skin, new->colormap,
player->skinname->value);
renderer->skin = mod_funcs->Skin_SetColormap (renderer->skin,
new->colormap);
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
} else {
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
renderer->skin = mod_funcs->Skin_SetColormap (renderer->skin,
0);
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
}
}
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
VectorCopy (ent_colormod[new->colormod], renderer->colormod);
renderer->colormod[3] = new->alpha / 255.0;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
renderer->min_light = 0;
renderer->fullbright = 0;
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
if (new->modelindex == cl_playerindex) {
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
renderer->min_light = min (cl.fbskins, cl_fb_players);
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
if (renderer->min_light >= 1.0) {
renderer->fullbright = 1;
}
grievre's patch to enable fullbright skins, controlled rotation and server control of various features
2004-07-11 01:41:01 +00:00
}
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
*old_origin = Transform_GetWorldPosition (transform);
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
if (forcelink) {
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
animation->pose1 = animation->pose2 = -1;
[renderer] Remove more old fields from entity_t The only transform related field remaining is old_origin. This also brings the renderer closer to using simd (lots of stuff to fix still, though).
2021-03-19 11:18:45 +00:00
CL_TransformEntity (ent, new->scale / 16, new->angles,
new->origin);
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
if (i != cl.viewentity || chase_active) {
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
if (visibility->efrag) {
[renderer] Move some functions from plugins to main lib One step in cleaning up vid_render_funcs.
2022-03-07 04:40:04 +00:00
R_RemoveEfrags (ent);
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
}
[renderer] Use scene_t to set the model data This replaces *_NewMap with *_NewScene and adds SCR_NewScene to handle loading a new map (for quake) in the renderer, and will eventually be how any new scene is loaded.
2022-05-05 05:41:46 +00:00
R_AddEfrags (&cl_world.scene->worldmodel->brush, ent);
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
}
hopefully fix our rocket trail problem
2002-03-14 21:33:56 +00:00
} else {
[renderer] Remove more old fields from entity_t The only transform related field remaining is old_origin. This also brings the renderer closer to using simd (lots of stuff to fix still, though).
2021-03-19 11:18:45 +00:00
vec4f_t delta = new->origin - old->origin;
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
f = frac;
// If the delta is large, assume a teleport and don't lerp
Fix a bunch of float vs int bugs Just those made me glad I tried compiling with clang: running into those bugs would have lead to some serious headaches, I imagine.
2022-03-30 15:28:26 +00:00
if (fabs (delta[0]) > 100 || fabs (delta[1]) > 100
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
|| fabs (delta[2]) > 100) {
// assume a teleportation, not a motion
[renderer] Remove more old fields from entity_t The only transform related field remaining is old_origin. This also brings the renderer closer to using simd (lots of stuff to fix still, though).
2021-03-19 11:18:45 +00:00
CL_TransformEntity (ent, new->scale / 16, new->angles,
new->origin);
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
animation->pose1 = animation->pose2 = -1;
[qw] Fix an uninitialized var use Found by valgrind
2021-07-11 03:31:34 +00:00
} else if (!(renderer->model->flags & EF_ROTATE)) {
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
vec3_t angles, d;
[renderer] Remove more old fields from entity_t The only transform related field remaining is old_origin. This also brings the renderer closer to using simd (lots of stuff to fix still, though).
2021-03-19 11:18:45 +00:00
vec4f_t origin = old->origin + f * delta;
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
// interpolate the origin and angles
[qw] Fix an uninitialized var use Found by valgrind
2021-07-11 03:31:34 +00:00
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;
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
}
[qw] Fix an uninitialized var use Found by valgrind
2021-07-11 03:31:34 +00:00
VectorMultAdd (old->angles, f, d, angles);
[renderer] Remove more old fields from entity_t The only transform related field remaining is old_origin. This also brings the renderer closer to using simd (lots of stuff to fix still, though).
2021-03-19 11:18:45 +00:00
CL_TransformEntity (ent, new->scale / 16.0, angles, origin);
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
}
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
if (i != cl.viewentity || chase_active) {
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
vec4f_t org = Transform_GetWorldPosition (transform);
if (visibility->efrag) {
if (!VectorCompare (org, *old_origin)) {//FIXME
[renderer] Move some functions from plugins to main lib One step in cleaning up vid_render_funcs.
2022-03-07 04:40:04 +00:00
R_RemoveEfrags (ent);
[renderer] Use scene_t to set the model data This replaces *_NewMap with *_NewScene and adds SCR_NewScene to handle loading a new map (for quake) in the renderer, and will eventually be how any new scene is loaded.
2022-05-05 05:41:46 +00:00
R_AddEfrags (&cl_world.scene->worldmodel->brush, ent);
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
}
} else {
[renderer] Use scene_t to set the model data This replaces *_NewMap with *_NewScene and adds SCR_NewScene to handle loading a new map (for quake) in the renderer, and will eventually be how any new scene is loaded.
2022-05-05 05:41:46 +00:00
R_AddEfrags (&cl_world.scene->worldmodel->brush, ent);
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
}
Use efrags with packet entities. This fixes brush models in the software renderers.
2010-12-03 05:10:53 +00:00
}
sadly, I have to revert my low-copy code. it doesn't gain /enough/ to be worth the bugs it's introduced (it's extremely difficult to do both low-copy /and/ correct entity updates).
2001-12-03 05:36:39 +00:00
}
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
if (!visibility->efrag) {
[renderer] Use scene_t to set the model data This replaces *_NewMap with *_NewScene and adds SCR_NewScene to handle loading a new map (for quake) in the renderer, and will eventually be how any new scene is loaded.
2022-05-05 05:41:46 +00:00
R_AddEfrags (&cl_world.scene->worldmodel->brush, ent);
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
}
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
Factor out model based particle effects. Moving them into a separate function both cleans up entity linking and makes things easier for csqc when it comes.
2012-06-19 23:02:29 +00:00
// rotate binary objects locally
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
if (renderer->model->flags & EF_ROTATE) {
Factor out model based particle effects. Moving them into a separate function both cleans up entity linking and makes things easier for csqc when it comes.
2012-06-19 23:02:29 +00:00
vec3_t angles;
angles[PITCH] = 0;
angles[YAW] = anglemod (100 * cl.time);
angles[ROLL] = 0;
[renderer] Remove more old fields from entity_t The only transform related field remaining is old_origin. This also brings the renderer closer to using simd (lots of stuff to fix still, though).
2021-03-19 11:18:45 +00:00
CL_TransformEntity (ent, new->scale / 16.0, angles, new->origin);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
Fix the ghost entities in demo playback. Really, when cl_nodelta is in effect (eg, .qwd demo recording and thus playback). QW now uses the new shared entity state block as I'd intended. Thanks to the cleanup of ghost entities (ie, entities that have been removed but continue to be rendered), glsl overkill has gone from 157 to 163 fps :)
2012-07-05 10:06:35 +00:00
//CL_EntityEffects (i, ent, new);
[client] Merge nq/qw entity effects code
2021-03-11 02:25:04 +00:00
//CL_NewDlight (i, ent->origin, new->effects, 0, 0, cl.time);
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
vec4f_t org = Transform_GetWorldPosition (transform);
[renderer] Remove more old fields from entity_t The only transform related field remaining is old_origin. This also brings the renderer closer to using simd (lots of stuff to fix still, though).
2021-03-19 11:18:45 +00:00
if (VectorDistance_fast (old->origin, org) > (256 * 256))
old->origin = org;
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
if (renderer->model->flags & ~EF_ROTATE) {
[client] Merge nq/qw entity effects code
2021-03-11 02:25:04 +00:00
CL_ModelEffects (ent, -new->number, new->glow_color, cl.time);
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
}
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
}
make gcc more anal about prototypes, string constants and function visibility (ie, global functions must have a prototype)
2003-01-06 18:28:13 +00:00
static void
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
CL_UpdateFlagModels (entity_t ent, int key)
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
{
convert the flag offset calculation from switch to a lookup table. this should be a touch faster avoiding the extra jumps
2002-08-06 03:52:38 +00:00
static float flag_offsets[] = {
16.0, 22.0, 26.0, 25.0, 24.0, 18.0, // 29-34 axpain
16.0, 24.0, 24.0, 22.0, 18.0, 16.0, // 35-40 pain
};
Move the entity transform setup into the clients. This has several benifits: o The silly issue with alias model pitches being backwards is kept out of the renderer (it's a quakec thing: entites do their pitch backwards, but originally, only alias models were rotated. Hipnotic did brush entity rotations in the correct direction). o Angle to frame vector conversions are done only when the entity's angles vector changes, rather than every frame. This avoids a lot of unnecessary trig function calls. o Once transformed, an entity's frame vectors are always available. However, the vectors are left handed rather than right handed (ie, forward/left/up instead of forward/right/up): just a matter of watching the sign. This avoids even more trig calls (flag models in qw). o This paves the way for merging brush entity surface rendering with the world model surface rendering (the actual goal of this patch). o This also paves the way for using quaternions to represent entity orientation, as that would be a protocol change.
2011-12-15 03:06:03 +00:00
float f;
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
entity_t fent = CL_GetFlagEnt (key);
byte *active = Ent_GetComponent (fent.id, scene_active,
cl_world.scene->reg);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
if (!*active) {
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
return;
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
}
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
animation_t *animation = Ent_GetComponent (ent.id, scene_animation,
cl_world.scene->reg);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
Minor cleanups.
2002-06-30 16:19:37 +00:00
f = 14.0;
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
if (animation->frame >= 29 && animation->frame <= 40) {
f = flag_offsets[animation->frame - 29];
} else if (animation->frame >= 103 && animation->frame <= 118) {
if (animation->frame <= 106) { // 103-104 nailattack
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
f = 20.0; // 105-106 light
} else { // 107-112 rocketattack
f = 21.0; // 112-118 shotattack
}
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
[qw] Use efrags for carried flags This sorts out the unwanted use of R_EnqueueEntity, which will help with removing another global (r_ent_queue), which is necessary for threaded multi-pass rendering (ie, shadows).
2021-07-22 10:35:12 +00:00
vec4f_t scale = { 1, 1, 1, 1 };
// -45 degree roll (x is forward)
vec4f_t rotation = { -0.382683432, 0, 0, 0.923879533 };
[qw] Fix carried flag handling I guess some of the earlier entity/scene handling hadn't been tested for flags as no entity was ever being created for a flag. This fixes a segfault when another player carrying a flag is potentially visible. Also make the -16 Z offset local. It looks better than global, and the global was quite wrong anyway as it was incorrectly updating W (which caused me to spend way too long figuring out why positions were breaking). There are still issues with flag handling, and things are likely to change with the ECS updates, but at least this lets me test.
2022-10-22 03:42:32 +00:00
vec4f_t position = { -f, -22, -16, 1};
[qw] Use efrags for carried flags This sorts out the unwanted use of R_EnqueueEntity, which will help with removing another global (r_ent_queue), which is necessary for threaded multi-pass rendering (ie, shadows).
2021-07-22 10:35:12 +00:00
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
transform_t transform = Entity_Transform (fent);
Transform_SetLocalTransform (transform, scale, rotation, position);
[qw] Use efrags for carried flags This sorts out the unwanted use of R_EnqueueEntity, which will help with removing another global (r_ent_queue), which is necessary for threaded multi-pass rendering (ie, shadows).
2021-07-22 10:35:12 +00:00
}
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
static entity_t
CL_AddFlagModels (entity_t ent, int team, int key)
[qw] Use efrags for carried flags This sorts out the unwanted use of R_EnqueueEntity, which will help with removing another global (r_ent_queue), which is necessary for threaded multi-pass rendering (ie, shadows).
2021-07-22 10:35:12 +00:00
{
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
entity_t fent;
[qw] Use efrags for carried flags This sorts out the unwanted use of R_EnqueueEntity, which will help with removing another global (r_ent_queue), which is necessary for threaded multi-pass rendering (ie, shadows).
2021-07-22 10:35:12 +00:00
[qw] Fix carried flag handling I guess some of the earlier entity/scene handling hadn't been tested for flags as no entity was ever being created for a flag. This fixes a segfault when another player carrying a flag is potentially visible. Also make the -16 Z offset local. It looks better than global, and the global was quite wrong anyway as it was incorrectly updating W (which caused me to spend way too long figuring out why positions were breaking). There are still issues with flag handling, and things are likely to change with the ECS updates, but at least this lets me test.
2022-10-22 03:42:32 +00:00
fent = CL_GetFlagEnt (key);
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
byte *active = Ent_GetComponent (fent.id, scene_active,
cl_world.scene->reg);
[qw] Use efrags for carried flags This sorts out the unwanted use of R_EnqueueEntity, which will help with removing another global (r_ent_queue), which is necessary for threaded multi-pass rendering (ie, shadows).
2021-07-22 10:35:12 +00:00
if (cl_flagindex == -1) {
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
*active = 0;
return nullentity;
[qw] Use efrags for carried flags This sorts out the unwanted use of R_EnqueueEntity, which will help with removing another global (r_ent_queue), which is necessary for threaded multi-pass rendering (ie, shadows).
2021-07-22 10:35:12 +00:00
}
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
*active = 1;
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
transform_t ftransform = Entity_Transform (fent);
transform_t transform = Entity_Transform (ent);
if (!Transform_Valid (Transform_GetParent (ftransform))) {
[ecs] Move ECS core into its own library While the libraries are probably getting a little out of hand, the separation into its own directory is probably a good thing as an ECS should not be tied to scenes. This should make the ECS more generally useful.
2022-10-26 06:22:09 +00:00
Transform_SetParent (ftransform, transform);
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
}
[qw] Use efrags for carried flags This sorts out the unwanted use of R_EnqueueEntity, which will help with removing another global (r_ent_queue), which is necessary for threaded multi-pass rendering (ie, shadows).
2021-07-22 10:35:12 +00:00
CL_UpdateFlagModels (ent, key);
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
renderer_t *renderer = Ent_GetComponent (fent.id, scene_renderer,
cl_world.scene->reg);
renderer->model = cl_world.models.a[cl_flagindex];
renderer->skinnum = team;
Eliminate MAX_VISEDICTS. Unlimited visible entities. The renderer can now render as many entities as can be crammed into the currently visible set of nodes.
2010-12-03 05:54:39 +00:00
[qw] Use efrags for carried flags This sorts out the unwanted use of R_EnqueueEntity, which will help with removing another global (r_ent_queue), which is necessary for threaded multi-pass rendering (ie, shadows).
2021-07-22 10:35:12 +00:00
return fent;
}
static void
CL_RemoveFlagModels (int key)
{
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
entity_t fent;
[qw] Use efrags for carried flags This sorts out the unwanted use of R_EnqueueEntity, which will help with removing another global (r_ent_queue), which is necessary for threaded multi-pass rendering (ie, shadows).
2021-07-22 10:35:12 +00:00
[qw] Fix carried flag handling I guess some of the earlier entity/scene handling hadn't been tested for flags as no entity was ever being created for a flag. This fixes a segfault when another player carrying a flag is potentially visible. Also make the -16 Z offset local. It looks better than global, and the global was quite wrong anyway as it was incorrectly updating W (which caused me to spend way too long figuring out why positions were breaking). There are still issues with flag handling, and things are likely to change with the ECS updates, but at least this lets me test.
2022-10-22 03:42:32 +00:00
fent = CL_GetFlagEnt (key);
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
byte *active = Ent_GetComponent (fent.id, scene_active,
cl_world.scene->reg);
transform_t transform = Entity_Transform (fent);
*active = 0;
[ecs] Move ECS core into its own library While the libraries are probably getting a little out of hand, the separation into its own directory is probably a good thing as an ECS should not be tied to scenes. This should make the ECS more generally useful.
2022-10-26 06:22:09 +00:00
Transform_SetParent (transform, nulltransform);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
/*
CL_LinkPlayers
Create visible entities in the correct position
for all current players
*/
make gcc more anal about prototypes, string constants and function visibility (ie, global functions must have a prototype)
2003-01-06 18:28:13 +00:00
static void
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
CL_LinkPlayers (void)
{
Whitespace.
2001-09-10 17:32:22 +00:00
double playertime;
[qw] Use entity_state_t as a base for player_state_t This will, in the long run, help clean up a lot of the differences in the handling of entities in the clients.
2021-03-11 05:27:36 +00:00
int msec, oldphysent, j;
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
entity_t ent;
Whitespace.
2001-09-10 17:32:22 +00:00
frame_t *frame;
[qw] Use efrags for carried flags This sorts out the unwanted use of R_EnqueueEntity, which will help with removing another global (r_ent_queue), which is necessary for threaded multi-pass rendering (ie, shadows).
2021-07-22 10:35:12 +00:00
player_info_t *player;
Whitespace.
2001-09-10 17:32:22 +00:00
player_state_t exact;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
player_state_t *state;
Remove cl_predict_static, it doesn't need a cvar to control it anymore. Also some minor related cleanups.
2002-07-27 00:44:54 +00:00
qboolean clientplayer;
[client] Use vec4_t in entity_state_t And clean up the mess (sort of:P)
2021-03-11 07:19:49 +00:00
vec3_t ang = {0, 0, 0};
vec4f_t org;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
playertime = realtime - cls.latency + 0.02;
if (playertime > realtime)
playertime = realtime;
frame = &cl.frames[cl.parsecount & UPDATE_MASK];
[qw] Use efrags for carried flags This sorts out the unwanted use of R_EnqueueEntity, which will help with removing another global (r_ent_queue), which is necessary for threaded multi-pass rendering (ie, shadows).
2021-07-22 10:35:12 +00:00
for (j = 0, player = cl.players, state = frame->playerstate;
j < MAX_CLIENTS; j++, player++, state++) {
[renderer] Support multiple entity queues While there's currently only the one still, this will allow the entities to be multiply queued for multi-pass rendering (eg, shadows). As the avoidance of putting an entity in the same queue more than once relies on the entity id, all entities now come from the scene (which is stored in cl_world in the client code for nq and qw), thus the extensive changes in the clients.
2022-03-04 16:48:10 +00:00
ent = CL_GetEntity (j + 1);
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
visibility_t *visibility = Ent_GetComponent (ent.id, scene_visibility,
cl_world.scene->reg);
renderer_t *renderer = Ent_GetComponent (ent.id, scene_renderer,
cl_world.scene->reg);
animation_t *animation = Ent_GetComponent (ent.id, scene_animation,
cl_world.scene->reg);
if (visibility->efrag)
[renderer] Move some functions from plugins to main lib One step in cleaning up vid_render_funcs.
2022-03-07 04:40:04 +00:00
R_RemoveEfrags (ent);
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
if (Entity_Valid (player->flag_ent)) {
visibility_t *fvis = Ent_GetComponent (player->flag_ent.id,
scene_visibility,
cl_world.scene->reg);
if (fvis->efrag) {
R_RemoveEfrags (player->flag_ent);
}
[qw] Use efrags for carried flags This sorts out the unwanted use of R_EnqueueEntity, which will help with removing another global (r_ent_queue), which is necessary for threaded multi-pass rendering (ie, shadows).
2021-07-22 10:35:12 +00:00
}
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
if (state->messagenum != cl.parsecount)
Re-enable rendering lights on the player you are viewing from...
2002-07-03 00:37:28 +00:00
continue; // not present this frame
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
[qw] Use efrags for carried flags This sorts out the unwanted use of R_EnqueueEntity, which will help with removing another global (r_ent_queue), which is necessary for threaded multi-pass rendering (ie, shadows).
2021-07-22 10:35:12 +00:00
if (!player->name || !player->name->value[0])
make sure unused player slots are skipped when linking (should fix elmex' segfault)
2002-03-15 16:49:40 +00:00
continue;
QSG2 glows almost working. Plus lots of typos killed.
2002-06-18 21:41:24 +00:00
// spawn light flashes, even ones coming from invisible objects
if (j == cl.playernum) {
[client] Get the basic chase camera working The more advanced modes are rather broken (continuous spinning), but they may have been for a while. The bulk of the various changes were due to renaming viewstate's origin and angles to make their meaning more explicit.
2022-03-01 02:43:23 +00:00
org = cl.viewstate.player_origin;
[renderer] Support multiple entity queues While there's currently only the one still, this will allow the entities to be multiply queued for multi-pass rendering (eg, shadows). As the avoidance of putting an entity in the same queue more than once relies on the entity id, all entities now come from the scene (which is stored in cl_world in the client code for nq and qw), thus the extensive changes in the clients.
2022-03-04 16:48:10 +00:00
cl.viewstate.player_entity = ent;
Remove cl_predict_static, it doesn't need a cvar to control it anymore. Also some minor related cleanups.
2002-07-27 00:44:54 +00:00
clientplayer = true;
} else {
[client] Use vec4_t in entity_state_t And clean up the mess (sort of:P)
2021-03-11 07:19:49 +00:00
org = state->pls.es.origin;
Remove cl_predict_static, it doesn't need a cvar to control it anymore. Also some minor related cleanups.
2002-07-27 00:44:54 +00:00
clientplayer = false;
}
[qw] Use efrags for carried flags This sorts out the unwanted use of R_EnqueueEntity, which will help with removing another global (r_ent_queue), which is necessary for threaded multi-pass rendering (ie, shadows).
2021-07-22 10:35:12 +00:00
if (player->chat && player->chat->value[0] != '0') {
[renderer] Move some functions from plugins to main lib One step in cleaning up vid_render_funcs.
2022-03-07 04:40:04 +00:00
dlight_t *dl = R_AllocDlight (j + 1);
Spawn a green dlight for chatting players. It's not very big, and shows as green only in gl, but at least there's some indication until I sort out icons etc.
2012-06-29 08:59:30 +00:00
VectorCopy (org, dl->origin);
dl->radius = 100;
dl->die = cl.time + 0.1;
QuatSet (0.0, 1.0, 0.0, 1.0, dl->color);
} else {
[qw] Use entity_state_t as a base for player_state_t This will, in the long run, help clean up a lot of the differences in the handling of entities in the clients.
2021-03-11 05:27:36 +00:00
CL_NewDlight (j + 1, org, state->pls.es.effects,
state->pls.es.glow_size, state->pls.es.glow_color,
cl.time);
Spawn a green dlight for chatting players. It's not very big, and shows as green only in gl, but at least there's some indication until I sort out icons etc.
2012-06-29 08:59:30 +00:00
}
QSG2 glows almost working. Plus lots of typos killed.
2002-06-18 21:41:24 +00:00
Remove cl_predict_static, it doesn't need a cvar to control it anymore. Also some minor related cleanups.
2002-07-27 00:44:54 +00:00
// Draw player?
if (!Cam_DrawPlayer (j))
continue;
Re-enable rendering lights on the player you are viewing from...
2002-07-03 00:37:28 +00:00
[qw] Use entity_state_t as a base for player_state_t This will, in the long run, help clean up a lot of the differences in the handling of entities in the clients.
2021-03-11 05:27:36 +00:00
if (!state->pls.es.modelindex)
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
continue;
// Hack hack hack
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
if (cl_deadbodyfilter
[qw] Use entity_state_t as a base for player_state_t This will, in the long run, help clean up a lot of the differences in the handling of entities in the clients.
2021-03-11 05:27:36 +00:00
&& state->pls.es.modelindex == cl_playerindex
&& is_dead_body (&state->pls.es))
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
continue;
audit the usage of "only" There are still a few iffy places (notably around certain prepositions), but the relevant sentences are now much easier to read.
2010-01-13 06:42:26 +00:00
// predict only half the move to minimize overruns
Order of operations cleanup, QSG2 alpha is now colormod[3] in entities.
2002-06-07 11:25:47 +00:00
msec = 500 * (playertime - state->state_time);
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
if (msec <= 0 || (!cl_predict_players) || cls.demoplayback2) {
[renderer] Remove more old fields from entity_t The only transform related field remaining is old_origin. This also brings the renderer closer to using simd (lots of stuff to fix still, though).
2021-03-19 11:18:45 +00:00
Sys_Printf("a\n");
exact.pls.es.origin = state->pls.es.origin;
Minor cleanups.
2002-06-30 16:19:37 +00:00
} else { // predict players movement
o misc little cleanups o add plent_state_t, packet_players_t and delta_t in preparation for re-worked delta compression code. o use plent_state_t in the client.
2005-04-30 03:59:23 +00:00
state->pls.cmd.msec = msec = min (msec, 255);
Order of operations cleanup, QSG2 alpha is now colormod[3] in entities.
2002-06-07 11:25:47 +00:00
oldphysent = pmove.numphysent;
CL_SetSolidPlayers (j);
[renderer] Remove more old fields from entity_t The only transform related field remaining is old_origin. This also brings the renderer closer to using simd (lots of stuff to fix still, though).
2021-03-19 11:18:45 +00:00
exact.pls.es.origin[3] = 1;//FIXME should be done by prediction
o misc little cleanups o add plent_state_t, packet_players_t and delta_t in preparation for re-worked delta compression code. o use plent_state_t in the client.
2005-04-30 03:59:23 +00:00
CL_PredictUsercmd (state, &exact, &state->pls.cmd, clientplayer);
Order of operations cleanup, QSG2 alpha is now colormod[3] in entities.
2002-06-07 11:25:47 +00:00
pmove.numphysent = oldphysent;
}
// angles
if (j == cl.playernum)
{
[client] Get the basic chase camera working The more advanced modes are rather broken (continuous spinning), but they may have been for a while. The bulk of the various changes were due to renaming viewstate's origin and angles to make their meaning more explicit.
2022-03-01 02:43:23 +00:00
ang[PITCH] = -cl.viewstate.player_angles[PITCH] / 3.0;
ang[YAW] = cl.viewstate.player_angles[YAW];
QSG2 glows almost working. Plus lots of typos killed.
2002-06-18 21:41:24 +00:00
} else {
Move the entity transform setup into the clients. This has several benifits: o The silly issue with alias model pitches being backwards is kept out of the renderer (it's a quakec thing: entites do their pitch backwards, but originally, only alias models were rotated. Hipnotic did brush entity rotations in the correct direction). o Angle to frame vector conversions are done only when the entity's angles vector changes, rather than every frame. This avoids a lot of unnecessary trig function calls. o Once transformed, an entity's frame vectors are always available. However, the vectors are left handed rather than right handed (ie, forward/left/up instead of forward/right/up): just a matter of watching the sign. This avoids even more trig calls (flag models in qw). o This paves the way for merging brush entity surface rendering with the world model surface rendering (the actual goal of this patch). o This also paves the way for using quaternions to represent entity orientation, as that would be a protocol change.
2011-12-15 03:06:03 +00:00
ang[PITCH] = -state->viewangles[PITCH] / 3.0;
ang[YAW] = state->viewangles[YAW];
Order of operations cleanup, QSG2 alpha is now colormod[3] in entities.
2002-06-07 11:25:47 +00:00
}
[qw] Use entity_state_t as a base for player_state_t This will, in the long run, help clean up a lot of the differences in the handling of entities in the clients.
2021-03-11 05:27:36 +00:00
ang[ROLL] = V_CalcRoll (ang, state->pls.es.velocity) * 4.0;
Order of operations cleanup, QSG2 alpha is now colormod[3] in entities.
2002-06-07 11:25:47 +00:00
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
if (renderer->model
[renderer] Support multiple entity queues While there's currently only the one still, this will allow the entities to be multiply queued for multi-pass rendering (eg, shadows). As the avoidance of putting an entity in the same queue more than once relies on the entity id, all entities now come from the scene (which is stored in cl_world in the client code for nq and qw), thus the extensive changes in the clients.
2022-03-04 16:48:10 +00:00
!= cl_world.models.a[state->pls.es.modelindex]) {
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
renderer->model = cl_world.models.a[state->pls.es.modelindex];
animation->nolerp = 1;
[qw] Disable lerping on player model change This seems to be an ancient bug, but may have been exposed by the recent entity changes (was certainly highlighted by Vulkan)
2021-03-19 13:54:20 +00:00
}
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
animation->frame = state->pls.es.frame;
renderer->skinnum = state->pls.es.skinnum;
grievre's patch to enable fullbright skins, controlled rotation and server control of various features
2004-07-11 01:41:01 +00:00
[renderer] Remove more old fields from entity_t The only transform related field remaining is old_origin. This also brings the renderer closer to using simd (lots of stuff to fix still, though).
2021-03-19 11:18:45 +00:00
//FIXME scale
CL_TransformEntity (ent, 1, ang, exact.pls.es.origin);
Move the entity transform setup into the clients. This has several benifits: o The silly issue with alias model pitches being backwards is kept out of the renderer (it's a quakec thing: entites do their pitch backwards, but originally, only alias models were rotated. Hipnotic did brush entity rotations in the correct direction). o Angle to frame vector conversions are done only when the entity's angles vector changes, rather than every frame. This avoids a lot of unnecessary trig function calls. o Once transformed, an entity's frame vectors are always available. However, the vectors are left handed rather than right handed (ie, forward/left/up instead of forward/right/up): just a matter of watching the sign. This avoids even more trig calls (flag models in qw). o This paves the way for merging brush entity surface rendering with the world model surface rendering (the actual goal of this patch). o This also paves the way for using quaternions to represent entity orientation, as that would be a protocol change.
2011-12-15 03:06:03 +00:00
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
renderer->min_light = 0;
renderer->fullbright = 0;
grievre's patch to enable fullbright skins, controlled rotation and server control of various features
2004-07-11 01:41:01 +00:00
[qw] Use entity_state_t as a base for player_state_t This will, in the long run, help clean up a lot of the differences in the handling of entities in the clients.
2021-03-11 05:27:36 +00:00
if (state->pls.es.modelindex == cl_playerindex) { //XXX
sadly, I have to revert my low-copy code. it doesn't gain /enough/ to be worth the bugs it's introduced (it's extremely difficult to do both low-copy /and/ correct entity updates).
2001-12-03 05:36:39 +00:00
// use custom skin
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
renderer->skin = player->skin;
Fix custom player skins for the sw renderers.
2012-01-23 14:38:32 +00:00
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
renderer->min_light = min (cl.fbskins, cl_fb_players);
grievre's patch to enable fullbright skins, controlled rotation and server control of various features
2004-07-11 01:41:01 +00:00
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
if (renderer->min_light >= 1.0) {
renderer->fullbright = 1;
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
}
sadly, I have to revert my low-copy code. it doesn't gain /enough/ to be worth the bugs it's introduced (it's extremely difficult to do both low-copy /and/ correct entity updates).
2001-12-03 05:36:39 +00:00
} else {
Avoid processing skins every frame. Processing skins every frame would slow things down unnecessarily, so call the skin functions only when something changes.
2012-01-24 01:28:07 +00:00
// FIXME no team colors on nonstandard player models
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
renderer->skin = 0;
sadly, I have to revert my low-copy code. it doesn't gain /enough/ to be worth the bugs it's introduced (it's extremely difficult to do both low-copy /and/ correct entity updates).
2001-12-03 05:36:39 +00:00
}
Whitespace.
2002-06-19 17:01:31 +00:00
[qw] Use efrags for carried flags This sorts out the unwanted use of R_EnqueueEntity, which will help with removing another global (r_ent_queue), which is necessary for threaded multi-pass rendering (ie, shadows).
2021-07-22 10:35:12 +00:00
int flag_state = state->pls.es.effects & (EF_FLAG1 | EF_FLAG2);
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
if (Entity_Valid (player->flag_ent) && !flag_state) {
[qw] Use efrags for carried flags This sorts out the unwanted use of R_EnqueueEntity, which will help with removing another global (r_ent_queue), which is necessary for threaded multi-pass rendering (ie, shadows).
2021-07-22 10:35:12 +00:00
CL_RemoveFlagModels (j);
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
player->flag_ent = (entity_t) nullentity;
} else if (!Entity_Valid (player->flag_ent) && flag_state) {
[qw] Use efrags for carried flags This sorts out the unwanted use of R_EnqueueEntity, which will help with removing another global (r_ent_queue), which is necessary for threaded multi-pass rendering (ie, shadows).
2021-07-22 10:35:12 +00:00
if (flag_state & EF_FLAG1)
player->flag_ent = CL_AddFlagModels (ent, 0, j);
else if (flag_state & EF_FLAG2)
player->flag_ent = CL_AddFlagModels (ent, 1, j);
}
Order of operations fix for R_AddEfrags.
2002-06-19 17:32:39 +00:00
// stuff entity in map
[renderer] Use scene_t to set the model data This replaces *_NewMap with *_NewScene and adds SCR_NewScene to handle loading a new map (for quake) in the renderer, and will eventually be how any new scene is loaded.
2022-05-05 05:41:46 +00:00
R_AddEfrags (&cl_world.scene->worldmodel->brush, ent);
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
if (Entity_Valid (player->flag_ent)) {
[qw] Use efrags for carried flags This sorts out the unwanted use of R_EnqueueEntity, which will help with removing another global (r_ent_queue), which is necessary for threaded multi-pass rendering (ie, shadows).
2021-07-22 10:35:12 +00:00
CL_UpdateFlagModels (ent, j);
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
entity_t fent = player->flag_ent;
R_AddEfrags (&cl_world.scene->worldmodel->brush, fent);
[qw] Use efrags for carried flags This sorts out the unwanted use of R_EnqueueEntity, which will help with removing another global (r_ent_queue), which is necessary for threaded multi-pass rendering (ie, shadows).
2021-07-22 10:35:12 +00:00
}
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
}
/*
CL_EmitEntities
Builds the visedicts array for cl.time
Made up of: clients, packet_entities, nails, and tents
*/
void
CL_EmitEntities (void)
{
if (cls.state != ca_active)
return;
if (!cl.validsequence)
return;
[client] Merge nq and qw temp entity handling This finally gets cl_tent merged away.
2021-03-10 09:00:16 +00:00
TEntContext_t tentCtx = {
[renderer] Support multiple entity queues While there's currently only the one still, this will allow the entities to be multiply queued for multi-pass rendering (eg, shadows). As the avoidance of putting an entity in the same queue more than once relies on the entity id, all entities now come from the scene (which is stored in cl_world in the client code for nq and qw), thus the extensive changes in the clients.
2022-03-04 16:48:10 +00:00
cl.viewstate.player_origin, cl.viewentity
[client] Merge nq and qw temp entity handling This finally gets cl_tent merged away.
2021-03-10 09:00:16 +00:00
};
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
CL_LinkPlayers ();
CL_LinkPacketEntities ();
[client] Merge nq and qw temp entity handling This finally gets cl_tent merged away.
2021-03-10 09:00:16 +00:00
CL_UpdateTEnts (cl.time, &tentCtx);
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
if (cl_draw_locs) {
[client] Get the basic chase camera working The more advanced modes are rather broken (continuous spinning), but they may have been for a while. The bulk of the various changes were due to renaming viewstate's origin and angles to make their meaning more explicit.
2022-03-01 02:43:23 +00:00
locs_draw (cl.time, cl.viewstate.player_origin);
cl_ents.c: bring back the location markers sv_ccmds.c: a few demo related fixes sv_demo.c: minor cleanups
2004-03-23 22:39:17 +00:00
}
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
void
CL_Ents_Init (void)
{
}
Reference in a new issue Copy permalink