qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-23 12:52:46 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/include/QF/ecs/hierarchy.h

91 lines
2.5 KiB
C
Raw Normal View History

[scene] Rename libQFentity to libQFscene And start working on scene management.
2021-07-24 05:19:52 +00:00
/*
[scene] Correct some typos in hierarchy.h Lost the y somewhere
2022-10-08 16:08:48 +00:00
hierarchy.h
[scene] Rename libQFentity to libQFscene And start working on scene management.
2021-07-24 05:19:52 +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
ECS Hierarchy management
[scene] Rename libQFentity to libQFscene And start working on scene management.
2021-07-24 05:19:52 +00:00
Copyright (C) 2021 Bill Currie <bill@taniwha.org>
Author: Bill Currie <bill@taniwha.org>
Date: 2021/02/26
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
*/
[ecs] Move ECS core into its own library While the libraries are probably getting a little out of hand, the separation into its own directory is probably a good thing as an ECS should not be tied to scenes. This should make the ECS more generally useful.
2022-10-26 06:22:09 +00:00
#ifndef __QF_ecs_hierarchy_h
#define __QF_ecs_hierarchy_h
[scene] Rename libQFentity to libQFscene And start working on scene management.
2021-07-24 05:19:52 +00:00
#include "QF/qtypes.h"
/** \defgroup entity Hierarchy management
\ingroup utils
*/
///@{
[scene] Move hierarchies to an ECS-based system This is the beginning of adding ECS to QF. While the previous iteration of hierarchies was a start in the direction towards ECS, this pulls most of the 3d-specific transform stuff out of the hierarchy "objects", making all the matrices and vectors/quaternions actual components (in the ECS sense). There's more work to be done with respect to the transform and entity members of hierarchy_t (entity should probably go away entirely, and transform should become hierref_t (or whatever its final name becomes), but I wanted to get things working sooner than later. The motivation for the effort was to allow views to use hierarchy_t, which should be possible once I get entity and transform sorted out. I am really glad I already had automated tests for hierarchies, as things proved to be a little tricky to get working due to forgetting why certain things were there.
2022-10-09 17:00:33 +00:00
/** Descriptors for components attached to every entity in the hierarchy.
*/
typedef struct hierarchy_type_s {
uint32_t num_components;
const struct component_s *components;
} hierarchy_type_t;
typedef struct hierref_s {
struct hierarchy_s *hierarchy;
uint32_t index; ///< index in hierarchy
} hierref_t;
[scene] Rename libQFentity to libQFscene And start working on scene management.
2021-07-24 05:19:52 +00:00
typedef struct hierarchy_s {
[scene] Move hierarchies to an ECS-based system This is the beginning of adding ECS to QF. While the previous iteration of hierarchies was a start in the direction towards ECS, this pulls most of the 3d-specific transform stuff out of the hierarchy "objects", making all the matrices and vectors/quaternions actual components (in the ECS sense). There's more work to be done with respect to the transform and entity members of hierarchy_t (entity should probably go away entirely, and transform should become hierref_t (or whatever its final name becomes), but I wanted to get things working sooner than later. The motivation for the effort was to allow views to use hierarchy_t, which should be possible once I get entity and transform sorted out. I am really glad I already had automated tests for hierarchies, as things proved to be a little tricky to get working due to forgetting why certain things were there.
2022-10-09 17:00:33 +00:00
uint32_t num_objects;
uint32_t max_objects;
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
uint32_t *ent;
[scene] Move hierarchies to an ECS-based system This is the beginning of adding ECS to QF. While the previous iteration of hierarchies was a start in the direction towards ECS, this pulls most of the 3d-specific transform stuff out of the hierarchy "objects", making all the matrices and vectors/quaternions actual components (in the ECS sense). There's more work to be done with respect to the transform and entity members of hierarchy_t (entity should probably go away entirely, and transform should become hierref_t (or whatever its final name becomes), but I wanted to get things working sooner than later. The motivation for the effort was to allow views to use hierarchy_t, which should be possible once I get entity and transform sorted out. I am really glad I already had automated tests for hierarchies, as things proved to be a little tricky to get working due to forgetting why certain things were there.
2022-10-09 17:00:33 +00:00
uint32_t *childCount;
uint32_t *childIndex;
uint32_t *parentIndex;
[ecs] Add "tree mode" to hierarchies As I had long suspected, building large hierarchies is fiendishly expensive (at least O(N^2)). However, this is because the hierarchies are structured such that adding high-level nodes results in a lot of copying due to the flattened (breadth-first) layout (which does make for excellent breadth-first performance when working with a hierarchy). Using tree mode allows adding new nodes to be O(1) (I guess O(N) for the size of the sub-tree being added, but that's not supported yet) and costs only an additional 8 bytes per node. Switching from flat mode to tree mode is very cheap as only the additional tree-related indices need to be fixed up (they're almost entirely ignored in flat mode). Switching from tree to flat mode is a little more expensive as the entire tree needs to be copied, but it seems to be an O(N) (size of the tree). With this, building the style editor window went from about 25% to about 5% (and most of that is realloc!), with a 1.3% cost for switching from tree mode to flat mode. There's still a lot of work to do (supporting removal and tree inserts).
2023-07-07 05:42:49 +00:00
uint32_t *nextIndex;
uint32_t *lastIndex;
[scene] Move hierarchies to an ECS-based system This is the beginning of adding ECS to QF. While the previous iteration of hierarchies was a start in the direction towards ECS, this pulls most of the 3d-specific transform stuff out of the hierarchy "objects", making all the matrices and vectors/quaternions actual components (in the ECS sense). There's more work to be done with respect to the transform and entity members of hierarchy_t (entity should probably go away entirely, and transform should become hierref_t (or whatever its final name becomes), but I wanted to get things working sooner than later. The motivation for the effort was to allow views to use hierarchy_t, which should be possible once I get entity and transform sorted out. I am really glad I already had automated tests for hierarchies, as things proved to be a little tricky to get working due to forgetting why certain things were there.
2022-10-09 17:00:33 +00:00
const hierarchy_type_t *type;
void **components;
[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
struct ecs_registry_s *reg;
[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
uint32_t href_comp;
[ecs] Add "tree mode" to hierarchies As I had long suspected, building large hierarchies is fiendishly expensive (at least O(N^2)). However, this is because the hierarchies are structured such that adding high-level nodes results in a lot of copying due to the flattened (breadth-first) layout (which does make for excellent breadth-first performance when working with a hierarchy). Using tree mode allows adding new nodes to be O(1) (I guess O(N) for the size of the sub-tree being added, but that's not supported yet) and costs only an additional 8 bytes per node. Switching from flat mode to tree mode is very cheap as only the additional tree-related indices need to be fixed up (they're almost entirely ignored in flat mode). Switching from tree to flat mode is a little more expensive as the entire tree needs to be copied, but it seems to be an O(N) (size of the tree). With this, building the style editor window went from about 25% to about 5% (and most of that is realloc!), with a 1.3% cost for switching from tree mode to flat mode. There's still a lot of work to do (supporting removal and tree inserts).
2023-07-07 05:42:49 +00:00
bool tree_mode; // use for fast building
[scene] Rename libQFentity to libQFscene And start working on scene management.
2021-07-24 05:19:52 +00:00
} hierarchy_t;
[ecs] Add "tree mode" to hierarchies As I had long suspected, building large hierarchies is fiendishly expensive (at least O(N^2)). However, this is because the hierarchies are structured such that adding high-level nodes results in a lot of copying due to the flattened (breadth-first) layout (which does make for excellent breadth-first performance when working with a hierarchy). Using tree mode allows adding new nodes to be O(1) (I guess O(N) for the size of the sub-tree being added, but that's not supported yet) and costs only an additional 8 bytes per node. Switching from flat mode to tree mode is very cheap as only the additional tree-related indices need to be fixed up (they're almost entirely ignored in flat mode). Switching from tree to flat mode is a little more expensive as the entire tree needs to be copied, but it seems to be an O(N) (size of the tree). With this, building the style editor window went from about 25% to about 5% (and most of that is realloc!), with a 1.3% cost for switching from tree mode to flat mode. There's still a lot of work to do (supporting removal and tree inserts).
2023-07-07 05:42:49 +00:00
#define nullindex (~0u)
[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
hierarchy_t *Hierarchy_New (struct ecs_registry_s *reg, uint32_t href_comp,
[scene] Move hierarchies to an ECS-based system This is the beginning of adding ECS to QF. While the previous iteration of hierarchies was a start in the direction towards ECS, this pulls most of the 3d-specific transform stuff out of the hierarchy "objects", making all the matrices and vectors/quaternions actual components (in the ECS sense). There's more work to be done with respect to the transform and entity members of hierarchy_t (entity should probably go away entirely, and transform should become hierref_t (or whatever its final name becomes), but I wanted to get things working sooner than later. The motivation for the effort was to allow views to use hierarchy_t, which should be possible once I get entity and transform sorted out. I am really glad I already had automated tests for hierarchies, as things proved to be a little tricky to get working due to forgetting why certain things were there.
2022-10-09 17:00:33 +00:00
const hierarchy_type_t *type, int createRoot);
[scene] Implement Hierarchy_Copy It copies an entire hierarchy (minus actual entities, but I'm as yet unsure how to proceed with them), even across scenes as the source scene is irrelevant and the destination scene is used for creating the new transforms.
2022-05-08 02:14:00 +00:00
void Hierarchy_Reserve (hierarchy_t *hierarchy, uint32_t count);
[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
hierarchy_t *Hierarchy_Copy (struct ecs_registry_s *reg, uint32_t href_comp,
[ecs] Move ECS core into its own library While the libraries are probably getting a little out of hand, the separation into its own directory is probably a good thing as an ECS should not be tied to scenes. This should make the ECS more generally useful.
2022-10-26 06:22:09 +00:00
const hierarchy_t *src);
[scene] Rename libQFentity to libQFscene And start working on scene management.
2021-07-24 05:19:52 +00:00
void Hierarchy_Delete (hierarchy_t *hierarchy);
[ecs] Add "tree mode" to hierarchies As I had long suspected, building large hierarchies is fiendishly expensive (at least O(N^2)). However, this is because the hierarchies are structured such that adding high-level nodes results in a lot of copying due to the flattened (breadth-first) layout (which does make for excellent breadth-first performance when working with a hierarchy). Using tree mode allows adding new nodes to be O(1) (I guess O(N) for the size of the sub-tree being added, but that's not supported yet) and costs only an additional 8 bytes per node. Switching from flat mode to tree mode is very cheap as only the additional tree-related indices need to be fixed up (they're almost entirely ignored in flat mode). Switching from tree to flat mode is a little more expensive as the entire tree needs to be copied, but it seems to be an O(N) (size of the tree). With this, building the style editor window went from about 25% to about 5% (and most of that is realloc!), with a 1.3% cost for switching from tree mode to flat mode. There's still a lot of work to do (supporting removal and tree inserts).
2023-07-07 05:42:49 +00:00
void Hierarchy_SetTreeMode (hierarchy_t *hierarchy, bool tree_mode);
[scene] Rename libQFentity to libQFscene And start working on scene management.
2021-07-24 05:19:52 +00:00
uint32_t Hierarchy_InsertHierarchy (hierarchy_t *dst, const hierarchy_t *src,
uint32_t dstParent, uint32_t srcRoot);
[ecs] Optionally delete entities on hierarchy removal Useful for deleting an entire sub-hierarchy of entities.
2022-11-07 15:16:29 +00:00
void Hierarchy_RemoveHierarchy (hierarchy_t *hierarchy, uint32_t index,
int delEntities);
[ecs] Move parent setting logic into hierarchy It should have always been here, but when I first created the hierarchy and transform objects, I didn't know where things would go. Having two chunks of code for setting an entity's parent was too already too much, and I expect to have other hierarchy types. Doesn't fix the issues encountered with sbar, of course.
2022-11-05 08:38:14 +00:00
hierref_t Hierarchy_SetParent (hierarchy_t *dst, uint32_t dstParent,
hierarchy_t *src, uint32_t srcIndex);
[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
void Hierref_DestroyComponent (void *href);
[scene] Rename libQFentity to libQFscene And start working on scene management.
2021-07-24 05:19:52 +00:00
///@}
[ecs] Move ECS core into its own library While the libraries are probably getting a little out of hand, the separation into its own directory is probably a good thing as an ECS should not be tied to scenes. This should make the ECS more generally useful.
2022-10-26 06:22:09 +00:00
#endif//__QF_ecs_hierarchy_h
Reference in a new issue Copy permalink