qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-10 07:11:41 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/libs/ecs/test/test-subpools.c

347 lines
9.5 KiB
C
Raw Normal View History

[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
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include "QF/simd/types.h"
#include "QF/mathlib.h"
#include "QF/ecs.h"
[ecs] Add a function to move a subpool to be the last This has use when the order of components in the pool affects draw order (or has other significance), especially at the subpool level. I plan to use it for fixing overlapping windows in imui.
2023-07-08 10:55:37 +00:00
#define DFL "\e[39;49m"
#define BLK "\e[30;40m"
#define RED "\e[31;40m"
#define GRN "\e[32;40m"
#define ONG "\e[33;40m"
#define BLU "\e[34;40m"
#define MAG "\e[35;40m"
#define CYN "\e[36;40m"
#define WHT "\e[37;40m"
[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
enum test_components {
test_subpool,
test_obj,
[ecs] Add a function to move a subpool to be the last This has use when the order of components in the pool affects draw order (or has other significance), especially at the subpool level. I plan to use it for fixing overlapping windows in imui.
2023-07-08 10:55:37 +00:00
test_name,
[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
test_num_components
};
[ecs] Add a function to move a subpool to be the last This has use when the order of components in the pool affects draw order (or has other significance), especially at the subpool level. I plan to use it for fixing overlapping windows in imui.
2023-07-08 10:55:37 +00:00
#define prent(e) (Ent_Generation (e) >> ENT_IDBITS), (Ent_Index (e))
[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 uint32_t
obj_rangeid (ecs_registry_t *reg, uint32_t ent, uint32_t comp)
{
uint32_t sp_comp = comp - (test_obj - test_subpool);
return *(uint32_t *) Ent_GetComponent (ent, sp_comp, reg);
}
static const component_t test_components[] = {
[test_subpool] = {
.size = sizeof (uint32_t),
.name = "subpool",
},
[test_obj] = {
.size = sizeof (uint32_t),
.name = "obj",
.rangeid = obj_rangeid,
},
[ecs] Add a function to move a subpool to be the last This has use when the order of components in the pool affects draw order (or has other significance), especially at the subpool level. I plan to use it for fixing overlapping windows in imui.
2023-07-08 10:55:37 +00:00
[test_name] = {
.size = sizeof (const char *),
.name = "name",
},
[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] Add a function to move a subpool to be the last This has use when the order of components in the pool affects draw order (or has other significance), especially at the subpool level. I plan to use it for fixing overlapping windows in imui.
2023-07-08 10:55:37 +00:00
static void
set_ent_name (uint32_t ent, uint32_t base, ecs_registry_t *reg,
const char *name)
{
Ent_SetComponent (ent, base + test_name, reg, &name);
}
[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 void
dump_sp_ids (ecs_registry_t *reg, uint32_t comp)
{
ecs_pool_t *pool = &reg->comp_pools[comp];
uint32_t *ent = pool->dense;
uint32_t *id = pool->data;
for (uint32_t i = 0; i < pool->count; i++) {
[ecs] Add a function to move a subpool to be the last This has use when the order of components in the pool affects draw order (or has other significance), especially at the subpool level. I plan to use it for fixing overlapping windows in imui.
2023-07-08 10:55:37 +00:00
const char **n = Ent_GetComponent (ent[i], test_name, reg);
printf ("ent[%d]: %2d, %2d %s\n", i, ent[i], id[i], *n);
[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
check_subpool_ranges (ecs_subpool_t *subpool, uint32_t *expect)
{
uint32_t count = 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
uint32_t *range = subpool->ranges;
[ecs] Add a function to move a subpool to be the last This has use when the order of components in the pool affects draw order (or has other significance), especially at the subpool level. I plan to use it for fixing overlapping windows in imui.
2023-07-08 10:55:37 +00:00
int ret = 0;
[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
while (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 *r = range++;
uint32_t e = *expect++;
[ecs] Add a function to move a subpool to be the last This has use when the order of components in the pool affects draw order (or has other significance), especially at the subpool level. I plan to use it for fixing overlapping windows in imui.
2023-07-08 10:55:37 +00:00
printf ("%2d: %2d %2d\n", (int)(r - subpool->ranges), *r, e);
[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 (*r != e++) {
[ecs] Add a function to move a subpool to be the last This has use when the order of components in the pool affects draw order (or has other significance), especially at the subpool level. I plan to use it for fixing overlapping windows in imui.
2023-07-08 10:55:37 +00:00
ret = 1;
}
}
return ret;
}
static int
check_subpool_sorted (ecs_subpool_t *subpool)
{
uint32_t *sorted = subpool->sorted;
uint32_t *ranges = subpool->ranges;
uint32_t count = subpool->num_ranges - subpool->available;
for (uint32_t i = 0; i < count; i++) {
printf ("sorted[%d]: %d %d\n", i, sorted[i], ranges[sorted[i]]);
}
for (uint32_t i = 0; i < count; i++) {
for (uint32_t j = i + 1; j < count; j++) {
if (sorted[j] == sorted[i]) {
printf ("subpool sorted duplicated\n");
return 1;
}
if (sorted[j] >= count) {
printf ("subpool sorted out of bounds\n");
return 1;
}
if (ranges[sorted[j]] > ranges[count - 1]) {
printf ("subpool sorted bogus\n");
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
}
}
return 0;
}
static int
check_obj_comps (ecs_registry_t *reg, uint32_t comp, uint32_t *expect)
{
ecs_pool_t *pool = &reg->comp_pools[comp];
uint32_t *val = pool->data;
int fail = 0;
for (uint32_t i = 0; i < pool->count; i++) {
[ecs] Add a function to move a subpool to be the last This has use when the order of components in the pool affects draw order (or has other significance), especially at the subpool level. I plan to use it for fixing overlapping windows in imui.
2023-07-08 10:55:37 +00:00
const char **n = Ent_GetComponent (pool->dense[i], test_name, reg);
printf ("val[%d]: %2d %2d %s\n", i, val[i], expect[i], *n);
[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 (val[i] != expect[i]) {
fail = 1;
}
}
return fail;
}
int
main (void)
{
ecs_registry_t *reg = ECS_NewRegistry ();
uint32_t base = ECS_RegisterComponents (reg, test_components,
test_num_components);
ECS_CreateComponentPools (reg);
uint32_t sp1 = ECS_NewSubpoolRange (reg, base + test_obj);
uint32_t sp2 = ECS_NewSubpoolRange (reg, base + test_obj);
uint32_t sp3 = ECS_NewSubpoolRange (reg, base + test_obj);
[ecs] Add a function to move a subpool to be the last This has use when the order of components in the pool affects draw order (or has other significance), especially at the subpool level. I plan to use it for fixing overlapping windows in imui.
2023-07-08 10:55:37 +00:00
printf ("%d.%d %d.%d %d.%d\n", prent (sp1), prent (sp2), prent (sp3));
[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 (reg->subpools[base + test_subpool].num_ranges != 0
|| reg->subpools[base + test_subpool].available != 0) {
printf ("subpool not 0 count: %d %d\n",
reg->subpools[base + test_subpool].num_ranges,
reg->subpools[base + test_subpool].available);
return 1;
}
if (reg->subpools[base + test_obj].num_ranges != 3
|| reg->subpools[base + test_obj].available != 0) {
printf ("obj not 3 count: %d %d\n",
reg->subpools[base + test_obj].num_ranges,
reg->subpools[base + test_obj].available);
return 1;
}
for (uint32_t i = 0; i < reg->subpools[base + test_obj].num_ranges; i++) {
[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 (reg->subpools[base + test_obj].ranges[i] != 0) {
[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
printf ("end %d not 0 count: %d\n", i,
[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
reg->subpools[base + test_obj].ranges[i]);
[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 1;
}
}
uint32_t enta = ECS_NewEntity (reg);
uint32_t entb = ECS_NewEntity (reg);
uint32_t entc = ECS_NewEntity (reg);
uint32_t entd = ECS_NewEntity (reg);
uint32_t ente = ECS_NewEntity (reg);
uint32_t entf = ECS_NewEntity (reg);
uint32_t entg = ECS_NewEntity (reg);
uint32_t enth = ECS_NewEntity (reg);
Ent_SetComponent (enta, base + test_subpool, reg, &sp1);
Ent_SetComponent (entb, base + test_subpool, reg, &sp1);
Ent_SetComponent (entc, base + test_subpool, reg, &sp2);
Ent_SetComponent (entd, base + test_subpool, reg, &sp3);
Ent_SetComponent (ente, base + test_subpool, reg, &sp3);
Ent_SetComponent (entf, base + test_subpool, reg, &sp2);
Ent_SetComponent (entg, base + test_subpool, reg, &sp2);
Ent_SetComponent (enth, base + test_subpool, reg, &sp1);
[ecs] Add a function to move a subpool to be the last This has use when the order of components in the pool affects draw order (or has other significance), especially at the subpool level. I plan to use it for fixing overlapping windows in imui.
2023-07-08 10:55:37 +00:00
set_ent_name (enta, base, reg, MAG"a"DFL);
set_ent_name (entb, base, reg, MAG"b"DFL);
set_ent_name (entc, base, reg, ONG"c"DFL);
set_ent_name (entd, base, reg, CYN"d"DFL);
set_ent_name (ente, base, reg, CYN"e"DFL);
set_ent_name (entf, base, reg, ONG"f"DFL);
set_ent_name (entg, base, reg, ONG"g"DFL);
set_ent_name (enth, base, reg, MAG"h"DFL);
[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
dump_sp_ids (reg, base + test_subpool);
if (check_subpool_ranges (&reg->subpools[base + test_obj],
(uint32_t[]) { 0, 0, 0 })) {
printf ("oops\n");
return 1;
}
uint32_t val = 0;
Ent_SetComponent (enta, base + test_obj, reg, &val); val++;
Ent_SetComponent (entb, base + test_obj, reg, &val); val++;
Ent_SetComponent (entc, base + test_obj, reg, &val); val++;
Ent_SetComponent (entd, base + test_obj, reg, &val); val++;
Ent_SetComponent (ente, base + test_obj, reg, &val); val++;
Ent_SetComponent (entf, base + test_obj, reg, &val); val++;
Ent_SetComponent (entg, base + test_obj, reg, &val); val++;
Ent_SetComponent (enth, base + test_obj, reg, &val); val++;
if (check_subpool_ranges (&reg->subpools[base + test_obj],
(uint32_t[]) { 3, 6, 8 })) {
printf ("oops\n");
return 1;
}
if (check_obj_comps (reg, base + test_obj,
(uint32_t[]) { 0, 1, 7, 5, 6, 2, 4, 3 })) {
printf ("oops\n");
return 1;
}
Ent_RemoveComponent (entb, base + test_obj, reg);
if (check_subpool_ranges (&reg->subpools[base + test_obj],
(uint32_t[]) { 2, 5, 7 })) {
printf ("oops\n");
return 1;
}
if (check_obj_comps (reg, base + test_obj,
(uint32_t[]) { 0, 7, 2, 5, 6, 3, 4 })) {
printf ("oops\n");
return 1;
}
Ent_RemoveComponent (entd, base + test_obj, reg);
if (check_subpool_ranges (&reg->subpools[base + test_obj],
(uint32_t[]) { 2, 5, 6 })) {
printf ("oops\n");
return 1;
}
if (check_obj_comps (reg, base + test_obj,
(uint32_t[]) { 0, 7, 2, 5, 6, 4 })) {
printf ("oops\n");
return 1;
}
Ent_RemoveComponent (ente, base + test_obj, reg);
if (check_subpool_ranges (&reg->subpools[base + test_obj],
(uint32_t[]) { 2, 5, 5 })) {
printf ("oops\n");
return 1;
}
if (check_obj_comps (reg, base + test_obj,
(uint32_t[]) { 0, 7, 2, 5, 6 })) {
printf ("oops\n");
return 1;
}
Ent_SetComponent (entd, base + test_obj, reg, &val); val++;
Ent_SetComponent (ente, base + test_obj, reg, &val); val++;
if (check_subpool_ranges (&reg->subpools[base + test_obj],
(uint32_t[]) { 2, 5, 7 })) {
printf ("oops\n");
return 1;
}
if (check_obj_comps (reg, base + test_obj,
(uint32_t[]) { 0, 7, 2, 5, 6, 8, 9 })) {
printf ("oops\n");
return 1;
}
Ent_RemoveComponent (entc, base + test_obj, reg);
Ent_RemoveComponent (entf, base + test_obj, reg);
Ent_RemoveComponent (entg, base + test_obj, reg);
if (check_subpool_ranges (&reg->subpools[base + test_obj],
(uint32_t[]) { 2, 2, 4 })) {
printf ("oops\n");
return 1;
}
if (check_obj_comps (reg, base + test_obj,
(uint32_t[]) { 0, 7, 9, 8 })) {
printf ("oops\n");
return 1;
}
ECS_DelSubpoolRange (reg, base + test_obj, sp2);
if (check_subpool_ranges (&reg->subpools[base + test_obj],
(uint32_t[]) { 2, 4 })) {
printf ("oops\n");
return 1;
}
sp2 = ECS_NewSubpoolRange (reg, base + test_obj);
[ecs] Add a function to move a subpool to be the last This has use when the order of components in the pool affects draw order (or has other significance), especially at the subpool level. I plan to use it for fixing overlapping windows in imui.
2023-07-08 10:55:37 +00:00
printf ("sp2: %d.%d\n", prent (sp2));
[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 (check_subpool_ranges (&reg->subpools[base + test_obj],
(uint32_t[]) { 2, 4, 4 })) {
printf ("oops\n");
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
Ent_SetComponent (entc, base + test_subpool, reg, &sp2);
Ent_SetComponent (entf, base + test_subpool, reg, &sp2);
Ent_SetComponent (entg, base + test_subpool, reg, &sp2);
Ent_SetComponent (entc, base + test_obj, reg, &val); val++;
Ent_SetComponent (entf, base + test_obj, reg, &val); val++;
Ent_SetComponent (entg, base + test_obj, reg, &val); val++;
if (check_subpool_ranges (&reg->subpools[base + test_obj],
(uint32_t[]) { 2, 4, 7})) {
printf ("oops\n");
return 1;
}
if (check_obj_comps (reg, base + test_obj,
(uint32_t[]) { 0, 7, 9, 8, 10, 11, 12 })) {
printf ("oops\n");
return 1;
}
[ecs] Add a function to move a subpool to be the last This has use when the order of components in the pool affects draw order (or has other significance), especially at the subpool level. I plan to use it for fixing overlapping windows in imui.
2023-07-08 10:55:37 +00:00
if (check_subpool_sorted (&reg->subpools[base + test_obj])) {
printf ("oops\n");
return 1;
}
ECS_MoveSubpoolLast (reg, base + test_obj, sp3);
if (check_subpool_sorted (&reg->subpools[base + test_obj])) {
printf ("oops\n");
return 1;
}
if (check_subpool_ranges (&reg->subpools[base + test_obj],
(uint32_t[]) { 2, 5, 7})) {
printf ("oops\n");
return 1;
}
if (check_obj_comps (reg, base + test_obj,
(uint32_t[]) { 0, 7, 10, 11, 12, 9, 8 })) {
printf ("oops\n");
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
ECS_DelRegistry (reg);
return 0;
}
Reference in a new issue Copy permalink