qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-27 06:34:11 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/libs/ecs/entity.c

149 lines
4.3 KiB
C
Raw Normal View History

[ecs] Organize headers and code There's now a main ecs.h file that includes the sub-system headers, removing the need to explicitly include several header files, but the sub-systems are a less cluttered.
2022-12-13 04:36:51 +00:00
/*
entity.c
ECS entity management
Copyright (C) 2022 Bill Currke
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "QF/heapsort.h"
#include "QF/sys.h"
#define IMPLEMENT_ECS_ENTITY_Funcs
#include "QF/ecs.h"
[ecs] Add support for subpools Subpools are for grouping components by some criterion. Any component that has a rangeid callback will be grouped with other components that return the same render id. Note that the ordering of components within a group will be affected by adding a component into a group that comes before that group (or removing a component). Component pools can have multiple groups, added and removed dynamically, but removing a group should (currently) be done only when empty.
2022-12-18 12:11:21 +00:00
#include "compat.h"
static void swap_inds (uint32_t *a, uint32_t *b)
{
uint32_t t = *a;
*a = *b;
*b = t;
}
[ecs] Organize headers and code There's now a main ecs.h file that includes the sub-system headers, removing the need to explicitly include several header files, but the sub-systems are a less cluttered.
2022-12-13 04:36:51 +00:00
VISIBLE void *
Ent_AddComponent (uint32_t ent, uint32_t comp, ecs_registry_t *registry)
{
ecs_pool_t *pool = &registry->comp_pools[comp];
[ecs] Add support for subpools Subpools are for grouping components by some criterion. Any component that has a rangeid callback will be grouped with other components that return the same render id. Note that the ordering of components within a group will be affected by adding a component into a group that comes before that group (or removing a component). Component pools can have multiple groups, added and removed dynamically, but removing a group should (currently) be done only when empty.
2022-12-18 12:11:21 +00:00
ecs_subpool_t *subpool = &registry->subpools[comp];
component_t *c = &registry->components.a[comp];
[ecs] Organize headers and code There's now a main ecs.h file that includes the sub-system headers, removing the need to explicitly include several header files, but the sub-systems are a less cluttered.
2022-12-13 04:36:51 +00:00
uint32_t id = Ent_Index (ent);
uint32_t ind = pool->sparse[id];
if (ind >= pool->count || pool->dense[ind] != ent) {
if (pool->count == pool->max_count) {
pool->max_count += COMP_GROW;
pool->dense = realloc (pool->dense,
pool->max_count * sizeof (uint32_t));
[ecs] Add support for subpools Subpools are for grouping components by some criterion. Any component that has a rangeid callback will be grouped with other components that return the same render id. Note that the ordering of components within a group will be affected by adding a component into a group that comes before that group (or removing a component). Component pools can have multiple groups, added and removed dynamically, but removing a group should (currently) be done only when empty.
2022-12-18 12:11:21 +00:00
Component_ResizeArray (c, &pool->data, pool->max_count);
[ecs] Organize headers and code There's now a main ecs.h file that includes the sub-system headers, removing the need to explicitly include several header files, but the sub-systems are a less cluttered.
2022-12-13 04:36:51 +00:00
}
uint32_t ind = pool->count++;
pool->sparse[id] = ind;
pool->dense[ind] = ent;
[ecs] Add support for subpools Subpools are for grouping components by some criterion. Any component that has a rangeid callback will be grouped with other components that return the same render id. Note that the ordering of components within a group will be affected by adding a component into a group that comes before that group (or removing a component). Component pools can have multiple groups, added and removed dynamically, but removing a group should (currently) be done only when empty.
2022-12-18 12:11:21 +00:00
uint32_t rind = subpool->num_ranges - subpool->available;
if (rind && c->rangeid) {
uint32_t rangeid = c->rangeid (registry, ent, comp);
uint32_t rangeind = subpool->sorted[Ent_Index (rangeid)];
while (rind-- > rangeind) {
[ecs] Adjust subpool range type to return start,end I found I needed the subrange start as well as the end, but I liked that the subpools themselves used only the end of the range, so switching to just a unint32_t for the value and adding a function to return a tuple made sense. I had kept the struct because I thought I might want to store additional information (eg, the entity "owning" the subpool), but found that I didn't need such information as the systems using subpools that way would have access to the entity by other means. Interestingly, the change found a bug in subpool creation: I really don't know why things worked before, but they work better now :)
2022-12-20 08:56:08 +00:00
if (subpool->ranges[rind] == ind) {
subpool->ranges[rind]++;
[ecs] Add support for subpools Subpools are for grouping components by some criterion. Any component that has a rangeid callback will be grouped with other components that return the same render id. Note that the ordering of components within a group will be affected by adding a component into a group that comes before that group (or removing a component). Component pools can have multiple groups, added and removed dynamically, but removing a group should (currently) be done only when empty.
2022-12-18 12:11:21 +00:00
continue;
}
[ecs] Adjust subpool range type to return start,end I found I needed the subrange start as well as the end, but I liked that the subpools themselves used only the end of the range, so switching to just a unint32_t for the value and adding a function to return a tuple made sense. I had kept the struct because I thought I might want to store additional information (eg, the entity "owning" the subpool), but found that I didn't need such information as the systems using subpools that way would have access to the entity by other means. Interestingly, the change found a bug in subpool creation: I really don't know why things worked before, but they work better now :)
2022-12-20 08:56:08 +00:00
uint32_t end = subpool->ranges[rind]++;
[ecs] Add support for subpools Subpools are for grouping components by some criterion. Any component that has a rangeid callback will be grouped with other components that return the same render id. Note that the ordering of components within a group will be affected by adding a component into a group that comes before that group (or removing a component). Component pools can have multiple groups, added and removed dynamically, but removing a group should (currently) be done only when empty.
2022-12-18 12:11:21 +00:00
Component_MoveElements (c, pool->data, ind, end, 1);
swap_inds (&pool->sparse[Ent_Index (pool->dense[end])],
&pool->sparse[Ent_Index (pool->dense[ind])]);
swap_inds (&pool->dense[ind], &pool->dense[end]);
ind = end;
}
}
[ecs] Organize headers and code There's now a main ecs.h file that includes the sub-system headers, removing the need to explicitly include several header files, but the sub-systems are a less cluttered.
2022-12-13 04:36:51 +00:00
}
return Ent_GetComponent (ent, comp, registry);
}
[ecs] Add support for subpools Subpools are for grouping components by some criterion. Any component that has a rangeid callback will be grouped with other components that return the same render id. Note that the ordering of components within a group will be affected by adding a component into a group that comes before that group (or removing a component). Component pools can have multiple groups, added and removed dynamically, but removing a group should (currently) be done only when empty.
2022-12-18 12:11:21 +00:00
static int
range_cmp (const void *_key, const void *_range, void *_subpool)
{
const uint32_t *key = _key;
[ecs] Adjust subpool range type to return start,end I found I needed the subrange start as well as the end, but I liked that the subpools themselves used only the end of the range, so switching to just a unint32_t for the value and adding a function to return a tuple made sense. I had kept the struct because I thought I might want to store additional information (eg, the entity "owning" the subpool), but found that I didn't need such information as the systems using subpools that way would have access to the entity by other means. Interestingly, the change found a bug in subpool creation: I really don't know why things worked before, but they work better now :)
2022-12-20 08:56:08 +00:00
const uint32_t *range = _range;
[ecs] Add support for subpools Subpools are for grouping components by some criterion. Any component that has a rangeid callback will be grouped with other components that return the same render id. Note that the ordering of components within a group will be affected by adding a component into a group that comes before that group (or removing a component). Component pools can have multiple groups, added and removed dynamically, but removing a group should (currently) be done only when empty.
2022-12-18 12:11:21 +00:00
ecs_subpool_t *subpool = _subpool;
[ecs] Handle indices beyond the subpools It turns out that the bsearch bug was hiding incorrect handling of indices in the subpool beyond the last tracked subpool. In which case, a correctly working bsearch correctly fails to find the range, but the search can be skipped entirely.
2023-03-05 07:10:09 +00:00
// range is the first index for the next subpool range
[ecs] Adjust subpool range type to return start,end I found I needed the subrange start as well as the end, but I liked that the subpools themselves used only the end of the range, so switching to just a unint32_t for the value and adding a function to return a tuple made sense. I had kept the struct because I thought I might want to store additional information (eg, the entity "owning" the subpool), but found that I didn't need such information as the systems using subpools that way would have access to the entity by other means. Interestingly, the change found a bug in subpool creation: I really don't know why things worked before, but they work better now :)
2022-12-20 08:56:08 +00:00
if (*key >= *range) {
[ecs] Find correct correct sub-pool range Returning -1 for key > value doesn't work too well for bsearch.
2023-01-21 16:04:23 +00:00
return 1;
[ecs] Add support for subpools Subpools are for grouping components by some criterion. Any component that has a rangeid callback will be grouped with other components that return the same render id. Note that the ordering of components within a group will be affected by adding a component into a group that comes before that group (or removing a component). Component pools can have multiple groups, added and removed dynamically, but removing a group should (currently) be done only when empty.
2022-12-18 12:11:21 +00:00
}
if (range - subpool->ranges > 0) {
[ecs] Adjust subpool range type to return start,end I found I needed the subrange start as well as the end, but I liked that the subpools themselves used only the end of the range, so switching to just a unint32_t for the value and adding a function to return a tuple made sense. I had kept the struct because I thought I might want to store additional information (eg, the entity "owning" the subpool), but found that I didn't need such information as the systems using subpools that way would have access to the entity by other means. Interestingly, the change found a bug in subpool creation: I really don't know why things worked before, but they work better now :)
2022-12-20 08:56:08 +00:00
return *key >= range[-1] ? 0 : -1;
[ecs] Add support for subpools Subpools are for grouping components by some criterion. Any component that has a rangeid callback will be grouped with other components that return the same render id. Note that the ordering of components within a group will be affected by adding a component into a group that comes before that group (or removing a component). Component pools can have multiple groups, added and removed dynamically, but removing a group should (currently) be done only when empty.
2022-12-18 12:11:21 +00:00
}
return 0;
}
[ecs] Adjust subpool range type to return start,end I found I needed the subrange start as well as the end, but I liked that the subpools themselves used only the end of the range, so switching to just a unint32_t for the value and adding a function to return a tuple made sense. I had kept the struct because I thought I might want to store additional information (eg, the entity "owning" the subpool), but found that I didn't need such information as the systems using subpools that way would have access to the entity by other means. Interestingly, the change found a bug in subpool creation: I really don't know why things worked before, but they work better now :)
2022-12-20 08:56:08 +00:00
static uint32_t *
[ecs] Add support for subpools Subpools are for grouping components by some criterion. Any component that has a rangeid callback will be grouped with other components that return the same render id. Note that the ordering of components within a group will be affected by adding a component into a group that comes before that group (or removing a component). Component pools can have multiple groups, added and removed dynamically, but removing a group should (currently) be done only when empty.
2022-12-18 12:11:21 +00:00
find_range (ecs_subpool_t *subpool, uint32_t ind)
{
return bsearch_r (&ind, subpool->ranges,
subpool->num_ranges - subpool->available,
[ecs] Adjust subpool range type to return start,end I found I needed the subrange start as well as the end, but I liked that the subpools themselves used only the end of the range, so switching to just a unint32_t for the value and adding a function to return a tuple made sense. I had kept the struct because I thought I might want to store additional information (eg, the entity "owning" the subpool), but found that I didn't need such information as the systems using subpools that way would have access to the entity by other means. Interestingly, the change found a bug in subpool creation: I really don't know why things worked before, but they work better now :)
2022-12-20 08:56:08 +00:00
sizeof (uint32_t), range_cmp, subpool);
[ecs] Add support for subpools Subpools are for grouping components by some criterion. Any component that has a rangeid callback will be grouped with other components that return the same render id. Note that the ordering of components within a group will be affected by adding a component into a group that comes before that group (or removing a component). Component pools can have multiple groups, added and removed dynamically, but removing a group should (currently) be done only when empty.
2022-12-18 12:11:21 +00:00
}
[ecs] Organize headers and code There's now a main ecs.h file that includes the sub-system headers, removing the need to explicitly include several header files, but the sub-systems are a less cluttered.
2022-12-13 04:36:51 +00:00
VISIBLE void
Ent_RemoveComponent (uint32_t ent, uint32_t comp, ecs_registry_t *registry)
{
uint32_t id = Ent_Index (ent);
ecs_pool_t *pool = &registry->comp_pools[comp];
[ecs] Add support for subpools Subpools are for grouping components by some criterion. Any component that has a rangeid callback will be grouped with other components that return the same render id. Note that the ordering of components within a group will be affected by adding a component into a group that comes before that group (or removing a component). Component pools can have multiple groups, added and removed dynamically, but removing a group should (currently) be done only when empty.
2022-12-18 12:11:21 +00:00
ecs_subpool_t *subpool = &registry->subpools[comp];
[ecs] Organize headers and code There's now a main ecs.h file that includes the sub-system headers, removing the need to explicitly include several header files, but the sub-systems are a less cluttered.
2022-12-13 04:36:51 +00:00
uint32_t ind = pool->sparse[id];
[ecs] Add support for subpools Subpools are for grouping components by some criterion. Any component that has a rangeid callback will be grouped with other components that return the same render id. Note that the ordering of components within a group will be affected by adding a component into a group that comes before that group (or removing a component). Component pools can have multiple groups, added and removed dynamically, but removing a group should (currently) be done only when empty.
2022-12-18 12:11:21 +00:00
component_t *c = &registry->components.a[comp];
[ecs] Organize headers and code There's now a main ecs.h file that includes the sub-system headers, removing the need to explicitly include several header files, but the sub-systems are a less cluttered.
2022-12-13 04:36:51 +00:00
if (ind < pool->count && pool->dense[ind] == ent) {
uint32_t last = pool->count - 1;
[ecs] Plug a bunch of memory leaks The hierarchy leak was particularly troublesome to fix, but now the hierarchies get updated (and freed) automatically just by removing the hierarchy reference component from the entity. I suspect there will be issues with entities that are on multiple hierarchies, but I'll sort that out later.
2023-03-05 12:29:26 +00:00
// invalidate the entity for this component to prevent the component
// being double-removed due to deletion of the component resulting
// in the entity being deleted (happens with hierarchies)
pool->dense[ind] = -1;
[ecs] Fix a bit of white space
2022-12-20 01:59:26 +00:00
Component_DestroyElements (c, pool->data, ind, 1);
[ecs] Handle indices beyond the subpools It turns out that the bsearch bug was hiding incorrect handling of indices in the subpool beyond the last tracked subpool. In which case, a correctly working bsearch correctly fails to find the range, but the search can be skipped entirely.
2023-03-05 07:10:09 +00:00
uint32_t range_count = subpool->num_ranges - subpool->available;
// if ind >= the last range, then it is outside the subpools
if (range_count && ind < subpool->ranges[range_count - 1]) {
[ecs] Adjust subpool range type to return start,end I found I needed the subrange start as well as the end, but I liked that the subpools themselves used only the end of the range, so switching to just a unint32_t for the value and adding a function to return a tuple made sense. I had kept the struct because I thought I might want to store additional information (eg, the entity "owning" the subpool), but found that I didn't need such information as the systems using subpools that way would have access to the entity by other means. Interestingly, the change found a bug in subpool creation: I really don't know why things worked before, but they work better now :)
2022-12-20 08:56:08 +00:00
uint32_t *range = find_range (subpool, ind);
Fix some mxe build issues
2023-03-25 12:36:45 +00:00
while ((size_t) (range - subpool->ranges) < range_count) {
[ecs] Adjust subpool range type to return start,end I found I needed the subrange start as well as the end, but I liked that the subpools themselves used only the end of the range, so switching to just a unint32_t for the value and adding a function to return a tuple made sense. I had kept the struct because I thought I might want to store additional information (eg, the entity "owning" the subpool), but found that I didn't need such information as the systems using subpools that way would have access to the entity by other means. Interestingly, the change found a bug in subpool creation: I really don't know why things worked before, but they work better now :)
2022-12-20 08:56:08 +00:00
uint32_t end = --*range;
[ecs] Add support for subpools Subpools are for grouping components by some criterion. Any component that has a rangeid callback will be grouped with other components that return the same render id. Note that the ordering of components within a group will be affected by adding a component into a group that comes before that group (or removing a component). Component pools can have multiple groups, added and removed dynamically, but removing a group should (currently) be done only when empty.
2022-12-18 12:11:21 +00:00
range++;
[ecs] Avoid shuffling components in empty ranges When bubbling a component past an empty range, there's no need for any actual movement other than adjusting the range itself, and doing so corrupts the sparse/dense array relationship. Fixes a segfault when hiding the deathmatch overlay (that resulted from the change to using canvases).
2023-01-21 04:58:43 +00:00
if (ind < end) {
pool->sparse[Ent_Index (pool->dense[end])] = ind;
pool->dense[ind] = pool->dense[end];
Component_MoveElements (c, pool->data, ind, end, 1);
ind = end;
}
[ecs] Add support for subpools Subpools are for grouping components by some criterion. Any component that has a rangeid callback will be grouped with other components that return the same render id. Note that the ordering of components within a group will be affected by adding a component into a group that comes before that group (or removing a component). Component pools can have multiple groups, added and removed dynamically, but removing a group should (currently) be done only when empty.
2022-12-18 12:11:21 +00:00
}
}
[ecs] Organize headers and code There's now a main ecs.h file that includes the sub-system headers, removing the need to explicitly include several header files, but the sub-systems are a less cluttered.
2022-12-13 04:36:51 +00:00
if (last > ind) {
pool->sparse[Ent_Index (pool->dense[last])] = ind;
pool->dense[ind] = pool->dense[last];
[ecs] Add support for subpools Subpools are for grouping components by some criterion. Any component that has a rangeid callback will be grouped with other components that return the same render id. Note that the ordering of components within a group will be affected by adding a component into a group that comes before that group (or removing a component). Component pools can have multiple groups, added and removed dynamically, but removing a group should (currently) be done only when empty.
2022-12-18 12:11:21 +00:00
Component_MoveElements (c, pool->data, ind, last, 1);
[ecs] Organize headers and code There's now a main ecs.h file that includes the sub-system headers, removing the need to explicitly include several header files, but the sub-systems are a less cluttered.
2022-12-13 04:36:51 +00:00
}
pool->count--;
pool->sparse[id] = nullent;
}
}
Reference in a new issue Copy permalink