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

903 lines
33 KiB
C
Raw Normal View History

[ecs] Add hierarchy-only tests The hierarchy-specific tests from the transform tests have been moved into the ecs tests and the transform tests renamed appropriately. As part of the process, hierarchies can now have a null type (ie, no additional components maintained by the hierarchy). This should make sorting out the issues highlighted by sbar a bit easier.
2022-11-05 12:26:47 +00:00
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <stdio.h>
#include <string.h>
#include <unistd.h>
[ecs] Split component registration from pool creation While this does require an extra call after registering components, it allows for multiple component sets (ie, sub-systems) to be registered before the component pools are created. The base id for the registered component set is returned so it can be passed to the subsystem as needed.
2022-12-13 13:58:44 +00:00
#include "QF/ecs.h"
[ecs] Add hierarchy-only tests The hierarchy-specific tests from the transform tests have been moved into the ecs tests and the transform tests renamed appropriately. As part of the process, hierarchies can now have a null type (ie, no additional components maintained by the hierarchy). This should make sorting out the issues highlighted by sbar a bit easier.
2022-11-05 12:26:47 +00:00
enum {
test_href,
test_name,
[ecs] Fix parent index updates when removing sub-hierarchies In the end, it was removal of the old entries that corrupted the parent indices. Very nicely, most of the fixes involved removing code. Taking advantage of the ECS to debug the hierarchies was fun, and the resulting colorized entity names helped no end.
2022-11-06 14:04:40 +00:00
test_highlight,
[ecs] Add hierarchy-only tests The hierarchy-specific tests from the transform tests have been moved into the ecs tests and the transform tests renamed appropriately. As part of the process, hierarchies can now have a null type (ie, no additional components maintained by the hierarchy). This should make sorting out the issues highlighted by sbar a bit easier.
2022-11-05 12:26:47 +00:00
test_num_components
};
static const component_t test_components[] = {
[test_href] = {
.size = sizeof (hierref_t),
.create = 0,//create_href,
.name = "href",
[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
.destroy = Hierref_DestroyComponent,
[ecs] Add hierarchy-only tests The hierarchy-specific tests from the transform tests have been moved into the ecs tests and the transform tests renamed appropriately. As part of the process, hierarchies can now have a null type (ie, no additional components maintained by the hierarchy). This should make sorting out the issues highlighted by sbar a bit easier.
2022-11-05 12:26:47 +00:00
},
[test_name] = {
.size = sizeof (const char *),
.name = "name",
},
[ecs] Fix parent index updates when removing sub-hierarchies In the end, it was removal of the old entries that corrupted the parent indices. Very nicely, most of the fixes involved removing code. Taking advantage of the ECS to debug the hierarchies was fun, and the resulting colorized entity names helped no end.
2022-11-06 14:04:40 +00:00
[test_highlight] = {
.size = sizeof (byte),
.name = "highlight",
},
[ecs] Add hierarchy-only tests The hierarchy-specific tests from the transform tests have been moved into the ecs tests and the transform tests renamed appropriately. As part of the process, hierarchies can now have a null type (ie, no additional components maintained by the hierarchy). This should make sorting out the issues highlighted by sbar a bit easier.
2022-11-05 12:26:47 +00:00
};
ecs_registry_t *test_reg;
[ecs] Colorize hierarchy test output Just the tiniest bit of color goes a long way to spotting issues.
2022-11-06 11:03:29 +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 hierarchy-only tests The hierarchy-specific tests from the transform tests have been moved into the ecs tests and the transform tests renamed appropriately. As part of the process, hierarchies can now have a null type (ie, no additional components maintained by the hierarchy). This should make sorting out the issues highlighted by sbar a bit easier.
2022-11-05 12:26:47 +00:00
static int
check_hierarchy_size (hierarchy_t *h, uint32_t size)
{
if (h->num_objects != size) {
printf ("hierarchy does not have exactly %u transform\n", size);
return 0;
}
ecs_registry_t *reg = h->reg;
for (uint32_t i = 0; i < h->num_objects; i++) {
hierref_t *ref = Ent_GetComponent (h->ent[i], test_href, reg);
char **name = Ent_GetComponent (h->ent[i], test_name, reg);;
if (ref->hierarchy != h) {
printf ("transform %d (%s) does not point to hierarchy\n",
i, *name);
}
}
return 1;
}
[ecs] Colorize hierarchy test output Just the tiniest bit of color goes a long way to spotting issues.
2022-11-06 11:03:29 +00:00
static const char *
ref_index_color (uint32_t i, uint32_t rind)
{
return rind != i ? RED : DFL;
}
static const char *
parent_index_color (hierarchy_t *h, uint32_t i)
{
if (!i && h->parentIndex[i] == nullent) {
return GRN;
}
if (h->parentIndex[i] >= i) {
return RED;
}
uint32_t ci = h->childIndex[h->parentIndex[i]];
uint32_t cc = h->childCount[h->parentIndex[i]];
if (i < ci || i >= ci + cc) {
return ONG;
}
return DFL;
}
static const char *
child_index_color (hierarchy_t *h, uint32_t i)
{
if (h->childIndex[i] > h->num_objects
|| h->childCount[i] > h->num_objects
|| h->childIndex[i] + h->childCount[i] > h->num_objects) {
return RED;
}
if (h->childIndex[i] <= i) {
return ONG;
}
return DFL;
}
static const char *
child_count_color (hierarchy_t *h, uint32_t i)
{
if (h->childIndex[i] > h->num_objects
|| h->childCount[i] > h->num_objects
|| h->childIndex[i] + h->childCount[i] > h->num_objects) {
return RED;
}
return DFL;
}
static const char *
entity_color (hierarchy_t *h, uint32_t i)
{
return h->ent[i] == nullent ? MAG : DFL;
}
[ecs] Fix parent index updates when removing sub-hierarchies In the end, it was removal of the old entries that corrupted the parent indices. Very nicely, most of the fixes involved removing code. Taking advantage of the ECS to debug the hierarchies was fun, and the resulting colorized entity names helped no end.
2022-11-06 14:04:40 +00:00
static const char *
highlight_color (hierarchy_t *h, uint32_t i)
{
uint32_t ent = h->ent[i];
if (ECS_EntValid (ent, test_reg)
&& Ent_HasComponent (ent, test_highlight, test_reg)) {
static char color_str[] = "\e[3.;4.m";
byte *color = Ent_GetComponent (ent, test_highlight, test_reg);
if (*color) {
byte fg = *color & 0x0f;
byte bg = *color >> 4;
color_str[3] = fg < 8 ? '0' + fg : '9';
color_str[6] = bg < 8 ? '0' + bg : '9';
return color_str;
}
}
return "";
}
[ecs] Add hierarchy-only tests The hierarchy-specific tests from the transform tests have been moved into the ecs tests and the transform tests renamed appropriately. As part of the process, hierarchies can now have a null type (ie, no additional components maintained by the hierarchy). This should make sorting out the issues highlighted by sbar a bit easier.
2022-11-05 12:26:47 +00:00
static void
dump_hierarchy (hierarchy_t *h)
{
ecs_registry_t *reg = h->reg;
[ecs] Add failing same-hierarchy parenting test As expected, reparenting a sub-hierarchy such that it (and possibly its children) move up the arrays fails (this is why sbar needs to first remove the sub-hierarchy then insert it).
2022-11-05 23:45:52 +00:00
puts ("in: ri pa ci cc en name");
[ecs] Add hierarchy-only tests The hierarchy-specific tests from the transform tests have been moved into the ecs tests and the transform tests renamed appropriately. As part of the process, hierarchies can now have a null type (ie, no additional components maintained by the hierarchy). This should make sorting out the issues highlighted by sbar a bit easier.
2022-11-05 12:26:47 +00:00
for (uint32_t i = 0; i < h->num_objects; i++) {
[ecs] Colorize hierarchy test output Just the tiniest bit of color goes a long way to spotting issues.
2022-11-06 11:03:29 +00:00
uint32_t rind = nullent;
static char fake_name[] = ONG "null" DFL;
static char *fake_nameptr = fake_name;
char **name = &fake_nameptr;
[ecs] Add failing same-hierarchy parenting test As expected, reparenting a sub-hierarchy such that it (and possibly its children) move up the arrays fails (this is why sbar needs to first remove the sub-hierarchy then insert it).
2022-11-05 23:45:52 +00:00
if (ECS_EntValid (h->ent[i], reg)) {
hierref_t *ref = Ent_GetComponent (h->ent[i], test_href, reg);
[ecs] Colorize hierarchy test output Just the tiniest bit of color goes a long way to spotting issues.
2022-11-06 11:03:29 +00:00
rind = ref->index;
[ecs] Add failing same-hierarchy parenting test As expected, reparenting a sub-hierarchy such that it (and possibly its children) move up the arrays fails (this is why sbar needs to first remove the sub-hierarchy then insert it).
2022-11-05 23:45:52 +00:00
if (Ent_HasComponent (h->ent[i], test_name, reg)) {
name = Ent_GetComponent (h->ent[i], test_name, reg);
}
}
[ecs] Fix parent index updates when removing sub-hierarchies In the end, it was removal of the old entries that corrupted the parent indices. Very nicely, most of the fixes involved removing code. Taking advantage of the ECS to debug the hierarchies was fun, and the resulting colorized entity names helped no end.
2022-11-06 14:04:40 +00:00
printf ("%2d: %s%2d %s%2d %s%2d %s%2d %s%2d"DFL" %s%s"DFL"\n", i,
[ecs] Colorize hierarchy test output Just the tiniest bit of color goes a long way to spotting issues.
2022-11-06 11:03:29 +00:00
ref_index_color (i, rind), rind,
parent_index_color (h, i), h->parentIndex[i],
child_index_color (h, i), h->childIndex[i],
child_count_color (h, i), h->childCount[i],
entity_color (h, i), h->ent[i],
[ecs] Fix parent index updates when removing sub-hierarchies In the end, it was removal of the old entries that corrupted the parent indices. Very nicely, most of the fixes involved removing code. Taking advantage of the ECS to debug the hierarchies was fun, and the resulting colorized entity names helped no end.
2022-11-06 14:04:40 +00:00
highlight_color (h, i), *name);
[ecs] Add hierarchy-only tests The hierarchy-specific tests from the transform tests have been moved into the ecs tests and the transform tests renamed appropriately. As part of the process, hierarchies can now have a null type (ie, no additional components maintained by the hierarchy). This should make sorting out the issues highlighted by sbar a bit easier.
2022-11-05 12:26:47 +00:00
}
puts ("");
}
[ecs] Add a failing hierarchy test This is the bug that sbar found when pulling a sub-hierarchy out of a larger hierarchy: child indices not getting updated correctly for later siblings and any niece objects.
2022-11-05 13:23:46 +00:00
static void
dump_tree (hierarchy_t *h, uint32_t ind, int level)
{
if (ind >= h->num_objects) {
printf ("index %d out of bounds (%d)\n", ind, h->num_objects);
return;
}
if (!level) {
[ecs] Add failing same-hierarchy parenting test As expected, reparenting a sub-hierarchy such that it (and possibly its children) move up the arrays fails (this is why sbar needs to first remove the sub-hierarchy then insert it).
2022-11-05 23:45:52 +00:00
puts ("in: pa ci cc en|name");
}
[ecs] Colorize hierarchy test output Just the tiniest bit of color goes a long way to spotting issues.
2022-11-06 11:03:29 +00:00
static char fake_name[] = ONG "null" DFL;
static char *fake_nameptr = fake_name;
char **name = &fake_nameptr;
[ecs] Add failing same-hierarchy parenting test As expected, reparenting a sub-hierarchy such that it (and possibly its children) move up the arrays fails (this is why sbar needs to first remove the sub-hierarchy then insert it).
2022-11-05 23:45:52 +00:00
ecs_registry_t *reg = h->reg;
[ecs] Colorize hierarchy test output Just the tiniest bit of color goes a long way to spotting issues.
2022-11-06 11:03:29 +00:00
if (ECS_EntValid (h->ent[ind], reg)
&& Ent_HasComponent (h->ent[ind], test_name, reg)) {
name = Ent_GetComponent (h->ent[ind], test_name, reg);;
}
[ecs] Fix parent index updates when removing sub-hierarchies In the end, it was removal of the old entries that corrupted the parent indices. Very nicely, most of the fixes involved removing code. Taking advantage of the ECS to debug the hierarchies was fun, and the resulting colorized entity names helped no end.
2022-11-06 14:04:40 +00:00
printf ("%2d: %s%2d %s%2d %s%2d %s%2d"DFL"|%*s%s%s"DFL"\n", ind,
[ecs] Colorize hierarchy test output Just the tiniest bit of color goes a long way to spotting issues.
2022-11-06 11:03:29 +00:00
parent_index_color (h, ind), h->parentIndex[ind],
child_index_color (h, ind), h->childIndex[ind],
child_count_color (h, ind), h->childCount[ind],
entity_color (h, ind), h->ent[ind],
[ecs] Fix parent index updates when removing sub-hierarchies In the end, it was removal of the old entries that corrupted the parent indices. Very nicely, most of the fixes involved removing code. Taking advantage of the ECS to debug the hierarchies was fun, and the resulting colorized entity names helped no end.
2022-11-06 14:04:40 +00:00
level * 3, "", highlight_color (h, ind), *name);
[ecs] Colorize hierarchy test output Just the tiniest bit of color goes a long way to spotting issues.
2022-11-06 11:03:29 +00:00
if (h->childIndex[ind] > ind) {
for (uint32_t i = 0; i < h->childCount[ind]; i++) {
if (h->childIndex[ind] + i >= h->num_objects) {
break;
}
dump_tree (h, h->childIndex[ind] + i, level + 1);
}
[ecs] Add a failing hierarchy test This is the bug that sbar found when pulling a sub-hierarchy out of a larger hierarchy: child indices not getting updated correctly for later siblings and any niece objects.
2022-11-05 13:23:46 +00:00
}
if (!level) {
puts ("");
}
}
[ecs] Add hierarchy-only tests The hierarchy-specific tests from the transform tests have been moved into the ecs tests and the transform tests renamed appropriately. As part of the process, hierarchies can now have a null type (ie, no additional components maintained by the hierarchy). This should make sorting out the issues highlighted by sbar a bit easier.
2022-11-05 12:26:47 +00:00
static int
check_indices (uint32_t ent, uint32_t index, uint32_t parentIndex,
uint32_t childIndex, uint32_t childCount)
{
ecs_registry_t *reg = test_reg;
char **entname = Ent_GetComponent (ent, test_name, reg);;
hierref_t *ref = Ent_GetComponent (ent, test_href, reg);
hierarchy_t *h = ref->hierarchy;
if (ref->index != index) {
char **name = Ent_GetComponent (h->ent[index], test_name, reg);;
printf ("%s/%s index incorrect: expect %u got %u\n",
*entname, *name,
index, ref->index);
return 0;
}
if (h->parentIndex[index] != parentIndex) {
printf ("%s parent index incorrect: expect %u got %u\n",
*entname, parentIndex, h->parentIndex[index]);
return 0;
}
if (h->childIndex[index] != childIndex) {
printf ("%s child index incorrect: expect %u got %u\n",
*entname, childIndex, h->childIndex[index]);
return 0;
}
if (h->childCount[index] != childCount) {
printf ("%s child count incorrect: expect %u got %u\n",
*entname, childCount, h->childCount[index]);
return 0;
}
return 1;
}
static uint32_t
create_ent (uint32_t parent, const char *name)
{
uint32_t ent = ECS_NewEntity (test_reg);
Ent_SetComponent (ent, test_name, test_reg, &name);
hierref_t *ref = Ent_AddComponent (ent, test_href, test_reg);
if (parent != nullent) {
hierref_t *pref = Ent_GetComponent (parent, test_href, test_reg);
ref->hierarchy = pref->hierarchy;
ref->index = Hierarchy_InsertHierarchy (pref->hierarchy, 0,
pref->index, 0);
} else {
[ecs] Move href_comp into hierarchy_t This means that the component id used for hierarchy references must be passed to Hierarchy_New and Hierarchy_Copy, but does all an entity to have more than one hierarchy, which is useful for canvases (hierarchies of views) in the 3d world (the canvas root would have a 3d hierarchy reference and a 2d (view) hierarchy reference).
2022-12-11 15:20:20 +00:00
ref->hierarchy = Hierarchy_New (test_reg, test_href, 0, 1);
[ecs] Add hierarchy-only tests The hierarchy-specific tests from the transform tests have been moved into the ecs tests and the transform tests renamed appropriately. As part of the process, hierarchies can now have a null type (ie, no additional components maintained by the hierarchy). This should make sorting out the issues highlighted by sbar a bit easier.
2022-11-05 12:26:47 +00:00
ref->index = 0;
}
ref->hierarchy->ent[ref->index] = ent;
return ent;
}
[ecs] Fix parent index updates when removing sub-hierarchies In the end, it was removal of the old entries that corrupted the parent indices. Very nicely, most of the fixes involved removing code. Taking advantage of the ECS to debug the hierarchies was fun, and the resulting colorized entity names helped no end.
2022-11-06 14:04:40 +00:00
static void
highlight_ent (uint32_t ent, byte color)
{
Ent_SetComponent (ent, test_highlight, test_reg, &color);
}
[ecs] Add hierarchy-only tests The hierarchy-specific tests from the transform tests have been moved into the ecs tests and the transform tests renamed appropriately. As part of the process, hierarchies can now have a null type (ie, no additional components maintained by the hierarchy). This should make sorting out the issues highlighted by sbar a bit easier.
2022-11-05 12:26:47 +00:00
static void
set_parent (uint32_t child, uint32_t parent)
{
if (parent != nullent) {
hierref_t *pref = Ent_GetComponent (parent, test_href, test_reg);
hierref_t *cref = Ent_GetComponent (child, test_href, test_reg);
Hierarchy_SetParent (pref->hierarchy, pref->index,
cref->hierarchy, cref->index);
} else {
hierref_t *cref = Ent_GetComponent (child, test_href, test_reg);
Hierarchy_SetParent (0, nullent, cref->hierarchy, cref->index);
}
}
static int
test_single_transform (void)
{
uint32_t ent = create_ent (nullent, "test");
hierarchy_t *h;
if (ent == nullent) {
printf ("create_ent returned null\n");
return 1;
}
hierref_t *ref = Ent_GetComponent (ent, test_href, test_reg);
if (!ref) {
printf ("Ent_GetComponent(test_href) returned null\n");
return 1;
}
if (!(h = ref->hierarchy)) {
printf ("New entity has no hierarchy\n");
return 1;
}
if (!check_hierarchy_size (h, 1)) { return 1; }
if (!check_indices (ent, 0, nullent, 1, 0)) { return 1; }
// Delete the hierarchy directly as setparent isn't fully tested
Hierarchy_Delete (h);
return 0;
}
static int
test_parent_child_init (void)
{
uint32_t parent = create_ent (nullent, "parent");
uint32_t child = create_ent (parent, "child");
hierref_t *pref = Ent_GetComponent (parent, test_href, test_reg);
hierref_t *cref = Ent_GetComponent (child, test_href, test_reg);
if (pref->hierarchy != cref->hierarchy) {
printf ("parent and child transforms have separate hierarchies\n");
return 1;
}
hierarchy_t *h = pref->hierarchy;
if (!check_hierarchy_size (h, 2)) { return 1; }
if (!check_indices (parent, 0, nullent, 1, 1)) { return 1; }
if (!check_indices (child, 1, 0, 2, 0)) { return 1; }
// Delete the hierarchy directly as setparent isn't fully tested
Hierarchy_Delete (h);
return 0;
}
static int
test_parent_child_setparent (void)
{
uint32_t parent = create_ent (nullent, "parent");
uint32_t child = create_ent (nullent, "child");
if (!check_indices (parent, 0, nullent, 1, 0)) { return 1; }
if (!check_indices (child, 0, nullent, 1, 0)) { return 1; }
hierref_t *pref = Ent_GetComponent (parent, test_href, test_reg);
hierref_t *cref = Ent_GetComponent (child, test_href, test_reg);
if (pref->hierarchy == cref->hierarchy) {
printf ("parent and child entities have same hierarchy before"
" set paret\n");
return 1;
}
set_parent (child, parent);
if (pref->hierarchy != cref->hierarchy) {
printf ("parent and child transforms have separate hierarchies\n");
return 1;
}
hierarchy_t *h = pref->hierarchy;
if (!check_hierarchy_size (h, 2)) { return 1; }
if (!check_indices (parent, 0, nullent, 1, 1)) { return 1; }
if (!check_indices (child, 1, 0, 2, 0)) { return 1; }
// Delete the hierarchy directly as setparent isn't fully tested
Hierarchy_Delete (h);
return 0;
}
static int
test_build_hierarchy (void)
{
printf ("test_build_hierarchy\n");
uint32_t root = create_ent (nullent, "root");
uint32_t A = create_ent (root, "A");
uint32_t B = create_ent (root, "B");
uint32_t C = create_ent (root, "C");
hierref_t *ref = Ent_GetComponent (root, test_href, test_reg);
if (!check_indices (root, 0, nullent, 1, 3)) { return 1; }
if (!check_indices (A, 1, 0, 4, 0)) { return 1; }
if (!check_indices (B, 2, 0, 4, 0)) { return 1; }
if (!check_indices (C, 3, 0, 4, 0)) { return 1; }
uint32_t B1 = create_ent (B, "B1");
if (!check_indices (root, 0, nullent, 1, 3)) { return 1; }
if (!check_indices ( A, 1, 0, 4, 0)) { return 1; }
if (!check_indices ( B, 2, 0, 4, 1)) { return 1; }
if (!check_indices ( C, 3, 0, 5, 0)) { return 1; }
if (!check_indices (B1, 4, 2, 5, 0)) { return 1; }
uint32_t A1 = create_ent (A, "A1");
if (!check_indices (root, 0, nullent, 1, 3)) { return 1; }
if (!check_indices ( A, 1, 0, 4, 1)) { return 1; }
if (!check_indices ( B, 2, 0, 5, 1)) { return 1; }
if (!check_indices ( C, 3, 0, 6, 0)) { return 1; }
if (!check_indices (A1, 4, 1, 6, 0)) { return 1; }
if (!check_indices (B1, 5, 2, 6, 0)) { return 1; }
uint32_t A1a = create_ent (A1, "A1a");
uint32_t B2 = create_ent (B, "B2");
uint32_t A2 = create_ent (A, "A2");
uint32_t B3 = create_ent (B, "B3");
uint32_t B2a = create_ent (B2, "B2a");
if (!check_hierarchy_size (ref->hierarchy, 11)) { return 1; }
if (!check_indices (root, 0, nullent, 1, 3)) { return 1; }
if (!check_indices ( A, 1, 0, 4, 2)) { return 1; }
if (!check_indices ( B, 2, 0, 6, 3)) { return 1; }
if (!check_indices ( C, 3, 0, 9, 0)) { return 1; }
if (!check_indices ( A1, 4, 1, 9, 1)) { return 1; }
if (!check_indices ( A2, 5, 1, 10, 0)) { return 1; }
if (!check_indices ( B1, 6, 2, 10, 0)) { return 1; }
if (!check_indices ( B2, 7, 2, 10, 1)) { return 1; }
if (!check_indices ( B3, 8, 2, 11, 0)) { return 1; }
if (!check_indices (A1a, 9, 4, 11, 0)) { return 1; }
if (!check_indices (B2a, 10, 7, 11, 0)) { return 1; }
uint32_t D = create_ent (root, "D");
if (!check_hierarchy_size (ref->hierarchy, 12)) { return 1; }
if (!check_indices (root, 0, nullent, 1, 4)) { return 1; }
if (!check_indices ( A, 1, 0, 5, 2)) { return 1; }
if (!check_indices ( B, 2, 0, 7, 3)) { return 1; }
if (!check_indices ( C, 3, 0, 10, 0)) { return 1; }
if (!check_indices ( D, 4, 0, 10, 0)) { return 1; }
if (!check_indices ( A1, 5, 1, 10, 1)) { return 1; }
if (!check_indices ( A2, 6, 1, 11, 0)) { return 1; }
if (!check_indices ( B1, 7, 2, 11, 0)) { return 1; }
if (!check_indices ( B2, 8, 2, 11, 1)) { return 1; }
if (!check_indices ( B3, 9, 2, 12, 0)) { return 1; }
if (!check_indices (A1a, 10, 5, 12, 0)) { return 1; }
if (!check_indices (B2a, 11, 8, 12, 0)) { return 1; }
dump_hierarchy (ref->hierarchy);
uint32_t C1 = create_ent (C, "C1");
dump_hierarchy (ref->hierarchy);
if (!check_hierarchy_size (ref->hierarchy, 13)) { return 1; }
if (!check_indices (root, 0, nullent, 1, 4)) { return 1; }
if (!check_indices ( A, 1, 0, 5, 2)) { return 1; }
if (!check_indices ( B, 2, 0, 7, 3)) { return 1; }
if (!check_indices ( C, 3, 0, 10, 1)) { return 1; }
if (!check_indices ( D, 4, 0, 11, 0)) { return 1; }
if (!check_indices ( A1, 5, 1, 11, 1)) { return 1; }
if (!check_indices ( A2, 6, 1, 12, 0)) { return 1; }
if (!check_indices ( B1, 7, 2, 12, 0)) { return 1; }
if (!check_indices ( B2, 8, 2, 12, 1)) { return 1; }
if (!check_indices ( B3, 9, 2, 13, 0)) { return 1; }
if (!check_indices ( C1, 10, 3, 13, 0)) { return 1; }
if (!check_indices (A1a, 11, 5, 13, 0)) { return 1; }
if (!check_indices (B2a, 12, 8, 13, 0)) { return 1; }
// Delete the hierarchy directly as setparent isn't fully tested
Hierarchy_Delete (ref->hierarchy);
return 0;
}
static int
test_build_hierarchy2 (void)
{
printf ("test_build_hierarchy2\n");
uint32_t root = create_ent (nullent, "root");
uint32_t A = create_ent (root, "A");
uint32_t B = create_ent (root, "B");
uint32_t C = create_ent (root, "C");
uint32_t B1 = create_ent (B, "B1");
uint32_t A1 = create_ent (A, "A1");
uint32_t A1a = create_ent (A1, "A1a");
uint32_t B2 = create_ent (B, "B2");
uint32_t A2 = create_ent (A, "A2");
uint32_t B3 = create_ent (B, "B3");
uint32_t B2a = create_ent (B2, "B2a");
uint32_t D = create_ent (root, "D");
uint32_t C1 = create_ent (C, "C1");
hierref_t *ref = Ent_GetComponent (root, test_href, test_reg);
if (!check_hierarchy_size (ref->hierarchy, 13)) { return 1; }
if (!check_indices (root, 0, nullent, 1, 4)) { return 1; }
if (!check_indices ( A, 1, 0, 5, 2)) { return 1; }
if (!check_indices ( B, 2, 0, 7, 3)) { return 1; }
if (!check_indices ( C, 3, 0, 10, 1)) { return 1; }
if (!check_indices ( D, 4, 0, 11, 0)) { return 1; }
if (!check_indices ( A1, 5, 1, 11, 1)) { return 1; }
if (!check_indices ( A2, 6, 1, 12, 0)) { return 1; }
if (!check_indices ( B1, 7, 2, 12, 0)) { return 1; }
if (!check_indices ( B2, 8, 2, 12, 1)) { return 1; }
if (!check_indices ( B3, 9, 2, 13, 0)) { return 1; }
if (!check_indices ( C1, 10, 3, 13, 0)) { return 1; }
if (!check_indices (A1a, 11, 5, 13, 0)) { return 1; }
if (!check_indices (B2a, 12, 8, 13, 0)) { return 1; }
uint32_t T = create_ent (nullent, "T");
uint32_t X = create_ent (T, "X");
uint32_t Y = create_ent (T, "Y");
uint32_t Z = create_ent (T, "Z");
uint32_t Y1 = create_ent (Y, "Y1");
uint32_t X1 = create_ent (X, "X1");
uint32_t X1a = create_ent (X1, "X1a");
uint32_t Y2 = create_ent (Y, "Y2");
uint32_t X2 = create_ent (X, "X2");
uint32_t Y3 = create_ent (Y, "Y3");
uint32_t Y2a = create_ent (Y2, "Y2a");
uint32_t Z1 = create_ent (Z, "Z1");
hierref_t *Tref = Ent_GetComponent (T, test_href, test_reg);
dump_hierarchy (Tref->hierarchy);
if (!check_hierarchy_size (Tref->hierarchy, 12)) { return 1; }
if (!check_indices ( T, 0, nullent, 1, 3)) { return 1; }
if (!check_indices ( X, 1, 0, 4, 2)) { return 1; }
if (!check_indices ( Y, 2, 0, 6, 3)) { return 1; }
if (!check_indices ( Z, 3, 0, 9, 1)) { return 1; }
if (!check_indices ( X1, 4, 1, 10, 1)) { return 1; }
if (!check_indices ( X2, 5, 1, 11, 0)) { return 1; }
if (!check_indices ( Y1, 6, 2, 11, 0)) { return 1; }
if (!check_indices ( Y2, 7, 2, 11, 1)) { return 1; }
if (!check_indices ( Y3, 8, 2, 12, 0)) { return 1; }
if (!check_indices ( Z1, 9, 3, 12, 0)) { return 1; }
if (!check_indices (X1a, 10, 4, 12, 0)) { return 1; }
if (!check_indices (Y2a, 11, 7, 12, 0)) { return 1; }
set_parent (T, B);
dump_hierarchy (ref->hierarchy);
if (!check_hierarchy_size (ref->hierarchy, 25)) { return 1; }
if (!check_indices (root, 0, nullent, 1, 4)) { return 1; }
if (!check_indices ( A, 1, 0, 5, 2)) { return 1; }
if (!check_indices ( B, 2, 0, 7, 4)) { return 1; }
if (!check_indices ( C, 3, 0, 11, 1)) { return 1; }
if (!check_indices ( D, 4, 0, 12, 0)) { return 1; }
if (!check_indices ( A1, 5, 1, 12, 1)) { return 1; }
if (!check_indices ( A2, 6, 1, 13, 0)) { return 1; }
if (!check_indices ( B1, 7, 2, 13, 0)) { return 1; }
if (!check_indices ( B2, 8, 2, 13, 1)) { return 1; }
if (!check_indices ( B3, 9, 2, 14, 0)) { return 1; }
if (!check_indices ( T, 10, 2, 14, 3)) { return 1; }
if (!check_indices ( C1, 11, 3, 17, 0)) { return 1; }
if (!check_indices (A1a, 12, 5, 17, 0)) { return 1; }
if (!check_indices (B2a, 13, 8, 17, 0)) { return 1; }
if (!check_indices ( X, 14, 10, 17, 2)) { return 1; }
if (!check_indices ( Y, 15, 10, 19, 3)) { return 1; }
if (!check_indices ( Z, 16, 10, 22, 1)) { return 1; }
if (!check_indices ( X1, 17, 14, 23, 1)) { return 1; }
if (!check_indices ( X2, 18, 14, 24, 0)) { return 1; }
if (!check_indices ( Y1, 19, 15, 24, 0)) { return 1; }
if (!check_indices ( Y2, 20, 15, 24, 1)) { return 1; }
if (!check_indices ( Y3, 21, 15, 25, 0)) { return 1; }
if (!check_indices ( Z1, 22, 16, 25, 0)) { return 1; }
if (!check_indices (X1a, 23, 17, 25, 0)) { return 1; }
if (!check_indices (Y2a, 24, 20, 25, 0)) { return 1; }
set_parent (Y, nullent);
dump_hierarchy (ref->hierarchy);
hierref_t *Yref = Ent_GetComponent (Y, test_href, test_reg);
dump_hierarchy (Yref->hierarchy);
if (!check_hierarchy_size (ref->hierarchy, 20)) { return 1; }
if (!check_hierarchy_size (Yref->hierarchy, 5)) { return 1; }
if (!check_indices (root, 0, nullent, 1, 4)) { return 1; }
if (!check_indices ( A, 1, 0, 5, 2)) { return 1; }
if (!check_indices ( B, 2, 0, 7, 4)) { return 1; }
if (!check_indices ( C, 3, 0, 11, 1)) { return 1; }
if (!check_indices ( D, 4, 0, 12, 0)) { return 1; }
if (!check_indices ( A1, 5, 1, 12, 1)) { return 1; }
if (!check_indices ( A2, 6, 1, 13, 0)) { return 1; }
if (!check_indices ( B1, 7, 2, 13, 0)) { return 1; }
if (!check_indices ( B2, 8, 2, 13, 1)) { return 1; }
if (!check_indices ( B3, 9, 2, 14, 0)) { return 1; }
[ecs] Fix some more hierarchy tests Ugh, things were quite bad, it turns out. It seems a lot of trouble would have been saved if these tests had worked (however, something is still not quite right as views are out of place).
2022-11-05 15:30:55 +00:00
if (!check_indices ( T, 10, 2, 14, 2)) { return 1; }
if (!check_indices ( C1, 11, 3, 16, 0)) { return 1; }
if (!check_indices (A1a, 12, 5, 16, 0)) { return 1; }
if (!check_indices (B2a, 13, 8, 16, 0)) { return 1; }
[ecs] Add hierarchy-only tests The hierarchy-specific tests from the transform tests have been moved into the ecs tests and the transform tests renamed appropriately. As part of the process, hierarchies can now have a null type (ie, no additional components maintained by the hierarchy). This should make sorting out the issues highlighted by sbar a bit easier.
2022-11-05 12:26:47 +00:00
if (!check_indices ( X, 14, 10, 16, 2)) { return 1; }
if (!check_indices ( Z, 15, 10, 18, 1)) { return 1; }
if (!check_indices ( X1, 16, 14, 19, 1)) { return 1; }
if (!check_indices ( X2, 17, 14, 20, 0)) { return 1; }
if (!check_indices ( Z1, 18, 15, 20, 0)) { return 1; }
if (!check_indices (X1a, 19, 16, 20, 0)) { return 1; }
if (!check_indices ( Y, 0, nullent, 1, 3)) { return 1; }
if (!check_indices ( Y1, 1, 0, 4, 0)) { return 1; }
if (!check_indices ( Y2, 2, 0, 4, 1)) { return 1; }
if (!check_indices ( Y3, 3, 0, 5, 0)) { return 1; }
if (!check_indices (Y2a, 4, 2, 5, 0)) { return 1; }
// Delete the hierarchy directly as setparent isn't fully tested
Hierarchy_Delete (ref->hierarchy);
Hierarchy_Delete (Yref->hierarchy);
return 0;
}
[ecs] Add a failing hierarchy test This is the bug that sbar found when pulling a sub-hierarchy out of a larger hierarchy: child indices not getting updated correctly for later siblings and any niece objects.
2022-11-05 13:23:46 +00:00
static int
test_build_hierarchy3 (void)
{
printf ("test_build_hierarchy3\n");
uint32_t root = create_ent (nullent, "root");
uint32_t A = create_ent (root, "A");
uint32_t B = create_ent (root, "B");
uint32_t C = create_ent (root, "C");
uint32_t B1 = create_ent (B, "B1");
uint32_t A1 = create_ent (A, "A1");
uint32_t A1a = create_ent (A1, "A1a");
uint32_t B2 = create_ent (B, "B2");
uint32_t A2 = create_ent (A, "A2");
uint32_t B3 = create_ent (B, "B3");
uint32_t B2a = create_ent (B2, "B2a");
uint32_t D = create_ent (root, "D");
uint32_t C1 = create_ent (C, "C1");
hierref_t *ref = Ent_GetComponent (root, test_href, test_reg);
dump_hierarchy (ref->hierarchy);
dump_tree (ref->hierarchy, 0, 0);
if (!check_hierarchy_size (ref->hierarchy, 13)) { return 1; }
if (!check_indices (root, 0, nullent, 1, 4)) { return 1; }
if (!check_indices ( A, 1, 0, 5, 2)) { return 1; }
if (!check_indices ( B, 2, 0, 7, 3)) { return 1; }
if (!check_indices ( C, 3, 0, 10, 1)) { return 1; }
if (!check_indices ( D, 4, 0, 11, 0)) { return 1; }
if (!check_indices ( A1, 5, 1, 11, 1)) { return 1; }
if (!check_indices ( A2, 6, 1, 12, 0)) { return 1; }
if (!check_indices ( B1, 7, 2, 12, 0)) { return 1; }
if (!check_indices ( B2, 8, 2, 12, 1)) { return 1; }
if (!check_indices ( B3, 9, 2, 13, 0)) { return 1; }
if (!check_indices ( C1, 10, 3, 13, 0)) { return 1; }
if (!check_indices (A1a, 11, 5, 13, 0)) { return 1; }
if (!check_indices (B2a, 12, 8, 13, 0)) { return 1; }
[ecs] Add failing same-hierarchy parenting test As expected, reparenting a sub-hierarchy such that it (and possibly its children) move up the arrays fails (this is why sbar needs to first remove the sub-hierarchy then insert it).
2022-11-05 23:45:52 +00:00
set_parent (B2, C1);
[ecs] Add a failing hierarchy test This is the bug that sbar found when pulling a sub-hierarchy out of a larger hierarchy: child indices not getting updated correctly for later siblings and any niece objects.
2022-11-05 13:23:46 +00:00
dump_hierarchy (ref->hierarchy);
dump_tree (ref->hierarchy, 0, 0);
[ecs] Rework new hierarchy test for same-hierarchy Since test_build_hierarchy2 already tested removal of a sub-hierarchy (once fixed), it seems test_build_hierarchy3 testing parenting within the same hierarchy would be a good idea. Reparenting such that everything moves to later in the arrays works nicely (not very surprising).
2022-11-05 23:36:43 +00:00
if (!check_hierarchy_size (ref->hierarchy, 13)) { return 1; }
[ecs] Add a failing hierarchy test This is the bug that sbar found when pulling a sub-hierarchy out of a larger hierarchy: child indices not getting updated correctly for later siblings and any niece objects.
2022-11-05 13:23:46 +00:00
[ecs] Rework new hierarchy test for same-hierarchy Since test_build_hierarchy2 already tested removal of a sub-hierarchy (once fixed), it seems test_build_hierarchy3 testing parenting within the same hierarchy would be a good idea. Reparenting such that everything moves to later in the arrays works nicely (not very surprising).
2022-11-05 23:36:43 +00:00
if (!check_indices (root, 0, nullent, 1, 4)) { return 1; }
if (!check_indices ( A, 1, 0, 5, 2)) { return 1; }
if (!check_indices ( B, 2, 0, 7, 2)) { return 1; }
[ecs] Add failing same-hierarchy parenting test As expected, reparenting a sub-hierarchy such that it (and possibly its children) move up the arrays fails (this is why sbar needs to first remove the sub-hierarchy then insert it).
2022-11-05 23:45:52 +00:00
if (!check_indices ( C, 3, 0, 9, 1)) { return 1; }
if (!check_indices ( D, 4, 0, 10, 0)) { return 1; }
if (!check_indices ( A1, 5, 1, 10, 1)) { return 1; }
if (!check_indices ( A2, 6, 1, 11, 0)) { return 1; }
if (!check_indices ( B1, 7, 2, 11, 0)) { return 1; }
if (!check_indices ( B3, 8, 2, 11, 0)) { return 1; }
if (!check_indices ( C1, 9, 3, 11, 1)) { return 1; }
if (!check_indices (A1a, 10, 5, 12, 0)) { return 1; }
if (!check_indices ( B2, 11, 9, 12, 1)) { return 1; }
if (!check_indices (B2a, 12, 11, 13, 0)) { return 1; }
uint32_t A1b = create_ent (A1, "A1b");
uint32_t A1c = create_ent (A1, "A1c");
uint32_t B2a1 = create_ent (B2a, "B2a1");
uint32_t B2a2 = create_ent (B2a, "B2a2");
uint32_t B2b = create_ent (B2, "B2b");
uint32_t B2b1 = create_ent (B2b, "B2b1");
uint32_t B2b2 = create_ent (B2b, "B2b2");
dump_hierarchy (ref->hierarchy);
dump_tree (ref->hierarchy, 0, 0);
if (!check_hierarchy_size (ref->hierarchy, 20)) { return 1; }
if (!check_indices (root, 0, nullent, 1, 4)) { return 1; }
if (!check_indices ( A, 1, 0, 5, 2)) { return 1; }
if (!check_indices ( B, 2, 0, 7, 2)) { return 1; }
if (!check_indices ( C, 3, 0, 9, 1)) { return 1; }
if (!check_indices ( D, 4, 0, 10, 0)) { return 1; }
if (!check_indices ( A1, 5, 1, 10, 3)) { return 1; }
if (!check_indices ( A2, 6, 1, 13, 0)) { return 1; }
if (!check_indices ( B1, 7, 2, 13, 0)) { return 1; }
if (!check_indices ( B3, 8, 2, 13, 0)) { return 1; }
if (!check_indices ( C1, 9, 3, 13, 1)) { return 1; }
if (!check_indices (A1a, 10, 5, 14, 0)) { return 1; }
if (!check_indices (A1b, 11, 5, 14, 0)) { return 1; }
if (!check_indices (A1c, 12, 5, 14, 0)) { return 1; }
if (!check_indices ( B2, 13, 9, 14, 2)) { return 1; }
if (!check_indices (B2a, 14, 13, 16, 2)) { return 1; }
if (!check_indices (B2b, 15, 13, 18, 2)) { return 1; }
if (!check_indices (B2a1, 16, 14, 20, 0)) { return 1; }
if (!check_indices (B2a2, 17, 14, 20, 0)) { return 1; }
if (!check_indices (B2b1, 18, 15, 20, 0)) { return 1; }
if (!check_indices (B2b2, 19, 15, 20, 0)) { return 1; }
set_parent (B2, root);
dump_hierarchy (ref->hierarchy);
dump_tree (ref->hierarchy, 0, 0);
if (!check_hierarchy_size (ref->hierarchy, 20)) { return 1; }
if (!check_indices (root, 0, nullent, 1, 5)) { return 1; }
if (!check_indices ( A, 1, 0, 6, 2)) { return 1; }
if (!check_indices ( B, 2, 0, 8, 2)) { return 1; }
if (!check_indices ( C, 3, 0, 10, 1)) { return 1; }
if (!check_indices ( D, 4, 0, 11, 0)) { return 1; }
if (!check_indices ( B2, 5, 0, 11, 2)) { return 1; }
if (!check_indices ( A1, 6, 1, 13, 3)) { return 1; }
if (!check_indices ( A2, 7, 1, 16, 0)) { return 1; }
if (!check_indices ( B1, 8, 2, 16, 0)) { return 1; }
if (!check_indices ( B3, 9, 2, 16, 0)) { return 1; }
if (!check_indices ( C1, 10, 3, 16, 0)) { return 1; }
if (!check_indices (B2a, 11, 5, 16, 2)) { return 1; }
if (!check_indices (B2b, 12, 5, 18, 2)) { return 1; }
if (!check_indices (A1a, 13, 6, 20, 0)) { return 1; }
if (!check_indices (A1b, 14, 6, 20, 0)) { return 1; }
if (!check_indices (A1c, 15, 6, 20, 0)) { return 1; }
if (!check_indices (B2a1, 16, 11, 20, 0)) { return 1; }
if (!check_indices (B2a2, 17, 11, 20, 0)) { return 1; }
if (!check_indices (B2b1, 18, 12, 20, 0)) { return 1; }
if (!check_indices (B2b2, 19, 12, 20, 0)) { return 1; }
[ecs] Add a failing hierarchy test This is the bug that sbar found when pulling a sub-hierarchy out of a larger hierarchy: child indices not getting updated correctly for later siblings and any niece objects.
2022-11-05 13:23:46 +00:00
// Delete the hierarchy directly as setparent isn't fully tested
Hierarchy_Delete (ref->hierarchy);
return 0;
}
[ecs] Add a simplified test of the sbar hierarchy Even 37 objects is a lot, but it's a whole lot better than 180. Most importantly, it reproduces the problem, which seems to be not all parent indices getting updated. The child indices seem to be working nice, as do the reference object indices (ie, the entity components). I suspect its the parent indices getting corrupted that cause problems on the second switch of the hud/sbar cvar as the parent indices are used to find the child indices that need to be updated.
2022-11-06 11:04:34 +00:00
static int
test_build_hierarchy4 (void)
{
printf ("test_build_hierarchy4\n");
uint32_t hud = create_ent (nullent, "hud");
uint32_t mt = create_ent (hud, "mt");
uint32_t mt_b = create_ent (mt, "mt_b");
uint32_t mt_b3 = create_ent (mt_b, "mt_b3");
uint32_t main = create_ent (hud, "main");
uint32_t main_mf = create_ent (main, "main_mf");
uint32_t main_mf_b = create_ent (main_mf, "main_mf_b");
uint32_t main_mf_b7 = create_ent (main_mf_b, "main_mf_b7");
uint32_t main_i = create_ent (main, "main_i");
uint32_t main_i_f = create_ent (main_i, "main_i_f");
uint32_t main_i_f_b = create_ent (main_i_f, "main_i_f_b");
uint32_t main_i_f_b4 = create_ent (main_i_f_b, "main_i_f_b4");
uint32_t main_i_s = create_ent (main_i, "main_i_s");
uint32_t main_i_s4 = create_ent (main_i_s, "main_i_s4");
uint32_t main_i_i = create_ent (main_i, "main_i_i");
uint32_t main_i_i4 = create_ent (main_i_i, "main_i_i4");
uint32_t main_i_a = create_ent (main_i, "main_i_a");
uint32_t main_i_a_w = create_ent (main_i_a, "main_i_a_w");
[ecs] Fix parent index updates when removing sub-hierarchies In the end, it was removal of the old entries that corrupted the parent indices. Very nicely, most of the fixes involved removing code. Taking advantage of the ECS to debug the hierarchies was fun, and the resulting colorized entity names helped no end.
2022-11-06 14:04:40 +00:00
uint32_t main_i_a_w7 = create_ent (main_i_a_w, "main_i_a_w7");
[ecs] Add a simplified test of the sbar hierarchy Even 37 objects is a lot, but it's a whole lot better than 180. Most importantly, it reproduces the problem, which seems to be not all parent indices getting updated. The child indices seem to be working nice, as do the reference object indices (ie, the entity components). I suspect its the parent indices getting corrupted that cause problems on the second switch of the hud/sbar cvar as the parent indices are used to find the child indices that need to be updated.
2022-11-06 11:04:34 +00:00
uint32_t main_i_a_ma = create_ent (main_i_a, "main_i_a_ma");
uint32_t main_i_a_ma4 = create_ent (main_i_a_ma, "main_i_a_ma4");
uint32_t main_sb = create_ent (main, "main_sb");
uint32_t main_sb_a = create_ent (main_sb, "main_sb_a");
uint32_t main_sb_a4 = create_ent (main_sb_a, "main_sb_a4");
uint32_t main_sb_f = create_ent (main_sb, "main_sb_f");
uint32_t main_sb_h = create_ent (main_sb, "main_sb_h");
uint32_t main_sb_h3 = create_ent (main_sb_h, "main_sb_h3");
uint32_t main_sb_A = create_ent (main_sb, "main_sb_A");
uint32_t main_sb_A4 = create_ent (main_sb_A, "main_sb_A4");
uint32_t main_t0 = create_ent (main, "main_t0");
uint32_t main_t1 = create_ent (main, "main_t1");
uint32_t main_S = create_ent (main, "main_S");
uint32_t main_S_m = create_ent (main_S, "main_S_m");
uint32_t main_S_s = create_ent (main_S, "main_S_s");
uint32_t main_S_t = create_ent (main_S, "main_S_t");
uint32_t main_S_a = create_ent (main_S, "main_S_a");
uint32_t main_S_a_n = create_ent (main_S_a, "main_S_a_n");
[ecs] Fix parent index updates when removing sub-hierarchies In the end, it was removal of the old entries that corrupted the parent indices. Very nicely, most of the fixes involved removing code. Taking advantage of the ECS to debug the hierarchies was fun, and the resulting colorized entity names helped no end.
2022-11-06 14:04:40 +00:00
highlight_ent (main_i_a, 0x06);
highlight_ent (main_i_a_w, 0x05);
highlight_ent (main_i_a_ma, 0x05);
highlight_ent (main_i_a_w7, 0x02);
highlight_ent (main_i_a_ma4, 0x02);
highlight_ent (main_sb_a, 0x03);
highlight_ent (main_sb_h, 0x03);
highlight_ent (main_sb_A, 0x03);
highlight_ent (main_S_a, 0x03);
highlight_ent (main_i_f_b, 0x03);
highlight_ent (main_sb_a4, 0x01);
highlight_ent (main_sb_h3, 0x01);
highlight_ent (main_sb_A4, 0x01);
highlight_ent (main_S_a_n, 0x01);
highlight_ent (main_i_f_b4, 0x01);
[ecs] Add a simplified test of the sbar hierarchy Even 37 objects is a lot, but it's a whole lot better than 180. Most importantly, it reproduces the problem, which seems to be not all parent indices getting updated. The child indices seem to be working nice, as do the reference object indices (ie, the entity components). I suspect its the parent indices getting corrupted that cause problems on the second switch of the hud/sbar cvar as the parent indices are used to find the child indices that need to be updated.
2022-11-06 11:04:34 +00:00
hierref_t *ref = Ent_GetComponent (hud, test_href, test_reg);
dump_hierarchy (ref->hierarchy);
dump_tree (ref->hierarchy, 0, 0);
if (!check_hierarchy_size (ref->hierarchy, 37)) { return 1; }
if (!check_indices (hud, 0, nullent, 1, 2)) { return 1; }
if (!check_indices (mt, 1, 0, 3, 1)) { return 1; }
if (!check_indices (main, 2, 0, 4, 6)) { return 1; }
if (!check_indices (mt_b, 3, 1, 10, 1)) { return 1; }
if (!check_indices (main_mf, 4, 2, 11, 1)) { return 1; }
if (!check_indices (main_i, 5, 2, 12, 4)) { return 1; }
if (!check_indices (main_sb, 6, 2, 16, 4)) { return 1; }
if (!check_indices (main_t0, 7, 2, 20, 0)) { return 1; }
if (!check_indices (main_t1, 8, 2, 20, 0)) { return 1; }
if (!check_indices (main_S, 9, 2, 20, 4)) { return 1; }
if (!check_indices (mt_b3, 10, 3, 24, 0)) { return 1; }
if (!check_indices (main_mf_b, 11, 4, 24, 1)) { return 1; }
if (!check_indices (main_i_f, 12, 5, 25, 1)) { return 1; }
if (!check_indices (main_i_s, 13, 5, 26, 1)) { return 1; }
if (!check_indices (main_i_i, 14, 5, 27, 1)) { return 1; }
if (!check_indices (main_i_a, 15, 5, 28, 2)) { return 1; }
if (!check_indices (main_sb_a, 16, 6, 30, 1)) { return 1; }
if (!check_indices (main_sb_f, 17, 6, 31, 0)) { return 1; }
if (!check_indices (main_sb_h, 18, 6, 31, 1)) { return 1; }
if (!check_indices (main_sb_A, 19, 6, 32, 1)) { return 1; }
if (!check_indices (main_S_m, 20, 9, 33, 0)) { return 1; }
if (!check_indices (main_S_s, 21, 9, 33, 0)) { return 1; }
if (!check_indices (main_S_t, 22, 9, 33, 0)) { return 1; }
if (!check_indices (main_S_a, 23, 9, 33, 1)) { return 1; }
if (!check_indices (main_mf_b7, 24, 11, 34, 0)) { return 1; }
if (!check_indices (main_i_f_b, 25, 12, 34, 1)) { return 1; }
if (!check_indices (main_i_s4, 26, 13, 35, 0)) { return 1; }
if (!check_indices (main_i_i4, 27, 14, 35, 0)) { return 1; }
if (!check_indices (main_i_a_w, 28, 15, 35, 1)) { return 1; }
if (!check_indices (main_i_a_ma, 29, 15, 36, 1)) { return 1; }
if (!check_indices (main_sb_a4, 30, 16, 37, 0)) { return 1; }
if (!check_indices (main_sb_h3, 31, 18, 37, 0)) { return 1; }
if (!check_indices (main_sb_A4, 32, 19, 37, 0)) { return 1; }
if (!check_indices (main_S_a_n, 33, 23, 37, 0)) { return 1; }
if (!check_indices (main_i_f_b4, 34, 25, 37, 0)) { return 1; }
[ecs] Fix parent index updates when removing sub-hierarchies In the end, it was removal of the old entries that corrupted the parent indices. Very nicely, most of the fixes involved removing code. Taking advantage of the ECS to debug the hierarchies was fun, and the resulting colorized entity names helped no end.
2022-11-06 14:04:40 +00:00
if (!check_indices (main_i_a_w7, 35, 28, 37, 0)) { return 1; }
[ecs] Add a simplified test of the sbar hierarchy Even 37 objects is a lot, but it's a whole lot better than 180. Most importantly, it reproduces the problem, which seems to be not all parent indices getting updated. The child indices seem to be working nice, as do the reference object indices (ie, the entity components). I suspect its the parent indices getting corrupted that cause problems on the second switch of the hud/sbar cvar as the parent indices are used to find the child indices that need to be updated.
2022-11-06 11:04:34 +00:00
if (!check_indices (main_i_a_ma4, 36, 29, 37, 0)) { return 1; }
set_parent (main_i_a, hud);
dump_hierarchy (ref->hierarchy);
dump_tree (ref->hierarchy, 0, 0);
if (!check_indices (hud, 0, nullent, 1, 3)) { return 1; }
if (!check_indices (mt, 1, 0, 4, 1)) { return 1; }
if (!check_indices (main, 2, 0, 5, 6)) { return 1; }
if (!check_indices (main_i_a, 3, 0, 11, 2)) { return 1; }
if (!check_indices (mt_b, 4, 1, 13, 1)) { return 1; }
if (!check_indices (main_mf, 5, 2, 14, 1)) { return 1; }
if (!check_indices (main_i, 6, 2, 15, 3)) { return 1; }
if (!check_indices (main_sb, 7, 2, 18, 4)) { return 1; }
if (!check_indices (main_t0, 8, 2, 22, 0)) { return 1; }
if (!check_indices (main_t1, 9, 2, 22, 0)) { return 1; }
if (!check_indices (main_S, 10, 2, 22, 4)) { return 1; }
if (!check_indices (main_i_a_w, 11, 3, 26, 1)) { return 1; }
if (!check_indices (main_i_a_ma, 12, 3, 27, 1)) { return 1; }
if (!check_indices (mt_b3, 13, 4, 28, 0)) { return 1; }
if (!check_indices (main_mf_b, 14, 5, 28, 1)) { return 1; }
if (!check_indices (main_i_f, 15, 6, 29, 1)) { return 1; }
if (!check_indices (main_i_s, 16, 6, 30, 1)) { return 1; }
if (!check_indices (main_i_i, 17, 6, 31, 1)) { return 1; }
if (!check_indices (main_sb_a, 18, 7, 32, 1)) { return 1; }
if (!check_indices (main_sb_f, 19, 7, 33, 0)) { return 1; }
if (!check_indices (main_sb_h, 20, 7, 33, 1)) { return 1; }
if (!check_indices (main_sb_A, 21, 7, 34, 1)) { return 1; }
if (!check_indices (main_S_m, 22, 10, 35, 0)) { return 1; }
if (!check_indices (main_S_s, 23, 10, 35, 0)) { return 1; }
if (!check_indices (main_S_t, 24, 10, 35, 0)) { return 1; }
if (!check_indices (main_S_a, 25, 10, 35, 1)) { return 1; }
[ecs] Fix parent index updates when removing sub-hierarchies In the end, it was removal of the old entries that corrupted the parent indices. Very nicely, most of the fixes involved removing code. Taking advantage of the ECS to debug the hierarchies was fun, and the resulting colorized entity names helped no end.
2022-11-06 14:04:40 +00:00
if (!check_indices (main_i_a_w7, 26, 11, 36, 0)) { return 1; }
[ecs] Add a simplified test of the sbar hierarchy Even 37 objects is a lot, but it's a whole lot better than 180. Most importantly, it reproduces the problem, which seems to be not all parent indices getting updated. The child indices seem to be working nice, as do the reference object indices (ie, the entity components). I suspect its the parent indices getting corrupted that cause problems on the second switch of the hud/sbar cvar as the parent indices are used to find the child indices that need to be updated.
2022-11-06 11:04:34 +00:00
if (!check_indices (main_i_a_ma4, 27, 12, 36, 0)) { return 1; }
if (!check_indices (main_mf_b7, 28, 14, 36, 0)) { return 1; }
if (!check_indices (main_i_f_b, 29, 15, 36, 1)) { return 1; }
if (!check_indices (main_i_s4, 30, 16, 37, 0)) { return 1; }
if (!check_indices (main_i_i4, 31, 17, 37, 0)) { return 1; }
if (!check_indices (main_sb_a4, 32, 18, 37, 0)) { return 1; }
if (!check_indices (main_sb_h3, 33, 20, 37, 0)) { return 1; }
if (!check_indices (main_sb_A4, 34, 21, 37, 0)) { return 1; }
if (!check_indices (main_S_a_n, 35, 25, 37, 0)) { return 1; }
if (!check_indices (main_i_f_b4, 36, 29, 37, 0)) { return 1; }
// Delete the hierarchy directly as setparent isn't fully tested
Hierarchy_Delete (ref->hierarchy);
return 0;
}
[ecs] Add hierarchy-only tests The hierarchy-specific tests from the transform tests have been moved into the ecs tests and the transform tests renamed appropriately. As part of the process, hierarchies can now have a null type (ie, no additional components maintained by the hierarchy). This should make sorting out the issues highlighted by sbar a bit easier.
2022-11-05 12:26:47 +00:00
int
main (void)
{
test_reg = ECS_NewRegistry ();
ECS_RegisterComponents (test_reg, test_components, test_num_components);
[ecs] Split component registration from pool creation While this does require an extra call after registering components, it allows for multiple component sets (ie, sub-systems) to be registered before the component pools are created. The base id for the registered component set is returned so it can be passed to the subsystem as needed.
2022-12-13 13:58:44 +00:00
ECS_CreateComponentPools (test_reg);
[ecs] Add hierarchy-only tests The hierarchy-specific tests from the transform tests have been moved into the ecs tests and the transform tests renamed appropriately. As part of the process, hierarchies can now have a null type (ie, no additional components maintained by the hierarchy). This should make sorting out the issues highlighted by sbar a bit easier.
2022-11-05 12:26:47 +00:00
if (test_single_transform ()) { return 1; }
if (test_parent_child_init ()) { return 1; }
if (test_parent_child_setparent ()) { return 1; }
if (test_build_hierarchy ()) { return 1; }
if (test_build_hierarchy2 ()) { return 1; }
[ecs] Add a failing hierarchy test This is the bug that sbar found when pulling a sub-hierarchy out of a larger hierarchy: child indices not getting updated correctly for later siblings and any niece objects.
2022-11-05 13:23:46 +00:00
if (test_build_hierarchy3 ()) { return 1; }
[ecs] Add a simplified test of the sbar hierarchy Even 37 objects is a lot, but it's a whole lot better than 180. Most importantly, it reproduces the problem, which seems to be not all parent indices getting updated. The child indices seem to be working nice, as do the reference object indices (ie, the entity components). I suspect its the parent indices getting corrupted that cause problems on the second switch of the hud/sbar cvar as the parent indices are used to find the child indices that need to be updated.
2022-11-06 11:04:34 +00:00
if (test_build_hierarchy4 ()) { return 1; }
[ecs] Add hierarchy-only tests The hierarchy-specific tests from the transform tests have been moved into the ecs tests and the transform tests renamed appropriately. As part of the process, hierarchies can now have a null type (ie, no additional components maintained by the hierarchy). This should make sorting out the issues highlighted by sbar a bit easier.
2022-11-05 12:26:47 +00:00
ECS_DelRegistry (test_reg);
return 0;
}
Reference in a new issue Copy permalink