qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-24 13:21:11 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/include/QF/scene/transform.h

94 lines
4 KiB
C
Raw Normal View History

[entity] Start work on a new entity library The plan is to have a fully component based entity system. This adds hierarchical transforms. Not particularly useful for quake itself at this stage, but it will allow for much more flexibility later on, especially when QuakeForge becomes more general-purpose.
2021-03-09 02:39:41 +00:00
/*
[scene] Rename libQFentity to libQFscene And start working on scene management.
2021-07-24 05:19:52 +00:00
transform.h
[entity] Start work on a new entity library The plan is to have a fully component based entity system. This adds hierarchical transforms. Not particularly useful for quake itself at this stage, but it will allow for much more flexibility later on, especially when QuakeForge becomes more general-purpose.
2021-03-09 02:39:41 +00:00
[scene] Rename libQFentity to libQFscene And start working on scene management.
2021-07-24 05:19:52 +00:00
Transform management
[entity] Start work on a new entity library The plan is to have a fully component based entity system. This adds hierarchical transforms. Not particularly useful for quake itself at this stage, but it will allow for much more flexibility later on, especially when QuakeForge becomes more general-purpose.
2021-03-09 02:39:41 +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
*/
[scene] Rename libQFentity to libQFscene And start working on scene management.
2021-07-24 05:19:52 +00:00
#ifndef __QF_scene_transform_h
#define __QF_scene_transform_h
[entity] Start work on a new entity library The plan is to have a fully component based entity system. This adds hierarchical transforms. Not particularly useful for quake itself at this stage, but it will allow for much more flexibility later on, especially when QuakeForge becomes more general-purpose.
2021-03-09 02:39:41 +00:00
#include "QF/darray.h"
[scene] Rename libQFentity to libQFscene And start working on scene management.
2021-07-24 05:19:52 +00:00
#include "QF/qtypes.h"
[entity] Start work on a new entity library The plan is to have a fully component based entity system. This adds hierarchical transforms. Not particularly useful for quake itself at this stage, but it will allow for much more flexibility later on, especially when QuakeForge becomes more general-purpose.
2021-03-09 02:39:41 +00:00
#include "QF/simd/vec4f.h"
#include "QF/simd/mat4f.h"
[scene] Rename libQFentity to libQFscene And start working on scene management.
2021-07-24 05:19:52 +00:00
/** \defgroup transform Transform management
[entity] Start work on a new entity library The plan is to have a fully component based entity system. This adds hierarchical transforms. Not particularly useful for quake itself at this stage, but it will allow for much more flexibility later on, especially when QuakeForge becomes more general-purpose.
2021-03-09 02:39:41 +00:00
\ingroup utils
*/
///@{
typedef struct transform_s {
[scene] Rename libQFentity to libQFscene And start working on scene management.
2021-07-24 05:19:52 +00:00
struct hierarchy_s *hierarchy;
[scene] Make transforms owned by the scene This actually has at least two benefits: the transform id is managed by the scene and thus does not need separate management by the Ruamoko wrapper functions, and better memory handling of the transform objects. Another benefit that isn't realized yet is that this is a step towards breaking the renderers free of quake and quakeworld: although the clients don't actually use the scene yet, it will be a good place to store the rendering information (functions to run, etc).
2022-02-14 11:01:36 +00:00
struct scene_s *scene; ///< owning scene
[scene] Add functions for scene and entity create/delete Scene creation was already there, but now can be deleted, as can entities.
2022-02-14 07:41:38 +00:00
uint32_t index; ///< index in hierarchy
int32_t id; ///< scene id
[entity] Start work on a new entity library The plan is to have a fully component based entity system. This adds hierarchical transforms. Not particularly useful for quake itself at this stage, but it will allow for much more flexibility later on, especially when QuakeForge becomes more general-purpose.
2021-03-09 02:39:41 +00:00
} transform_t;
[scene] Make transforms owned by the scene This actually has at least two benefits: the transform id is managed by the scene and thus does not need separate management by the Ruamoko wrapper functions, and better memory handling of the transform objects. Another benefit that isn't realized yet is that this is a step towards breaking the renderers free of quake and quakeworld: although the clients don't actually use the scene yet, it will be a good place to store the rendering information (functions to run, etc).
2022-02-14 11:01:36 +00:00
transform_t *Transform_New (struct scene_s *scene, transform_t *parent);
[scene] Add functions for scene and entity create/delete Scene creation was already there, but now can be deleted, as can entities.
2022-02-14 07:41:38 +00:00
/* Deletes all child transforms, and transform names */
[entity] Start work on a new entity library The plan is to have a fully component based entity system. This adds hierarchical transforms. Not particularly useful for quake itself at this stage, but it will allow for much more flexibility later on, especially when QuakeForge becomes more general-purpose.
2021-03-09 02:39:41 +00:00
void Transform_Delete (transform_t *transform);
[scene] Make transforms owned by the scene This actually has at least two benefits: the transform id is managed by the scene and thus does not need separate management by the Ruamoko wrapper functions, and better memory handling of the transform objects. Another benefit that isn't realized yet is that this is a step towards breaking the renderers free of quake and quakeworld: although the clients don't actually use the scene yet, it will be a good place to store the rendering information (functions to run, etc).
2022-02-14 11:01:36 +00:00
transform_t *Transform_NewNamed (struct scene_s *scene, transform_t *parent,
const char *name);
[entity] Start work on a new entity library The plan is to have a fully component based entity system. This adds hierarchical transforms. Not particularly useful for quake itself at this stage, but it will allow for much more flexibility later on, especially when QuakeForge becomes more general-purpose.
2021-03-09 02:39:41 +00:00
uint32_t Transform_ChildCount (const transform_t *transform) __attribute__((pure));
transform_t *Transform_GetChild (const transform_t *transform,
uint32_t childIndex) __attribute__((pure));
void Transform_SetParent (transform_t *transform, transform_t *parent);
transform_t *Transform_GetParent (const transform_t *transform) __attribute__((pure));
void Transform_SetName (transform_t *transform, const char *name);
const char *Transform_GetName (const transform_t *transform) __attribute__((pure));
void Transform_SetTag (transform_t *transform, uint32_t tag);
uint32_t Transform_GetTag (const transform_t *transform) __attribute__((pure));
void Transform_GetLocalMatrix (const transform_t *transform, mat4f_t mat);
void Transform_GetLocalInverse (const transform_t *transform, mat4f_t mat);
void Transform_GetWorldMatrix (const transform_t *transform, mat4f_t mat);
[scene] Provide direct access to the world matrix Holding onto the pointer is not a good idea, and it is read-only as direct manipulation of the world matrix is not supported. However, this is useful for passing the matrix to the GPU.
2021-12-17 07:42:31 +00:00
// XXX the pointer may be invalidated by hierarchy updates
const vec4f_t *Transform_GetWorldMatrixPtr (const transform_t *transform) __attribute__((pure));
[entity] Start work on a new entity library The plan is to have a fully component based entity system. This adds hierarchical transforms. Not particularly useful for quake itself at this stage, but it will allow for much more flexibility later on, especially when QuakeForge becomes more general-purpose.
2021-03-09 02:39:41 +00:00
void Transform_GetWorldInverse (const transform_t *transform, mat4f_t mat);
vec4f_t Transform_GetLocalPosition (const transform_t *transform) __attribute__((pure));
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
void Transform_SetLocalPosition (transform_t *transform, vec4f_t position);
[entity] Start work on a new entity library The plan is to have a fully component based entity system. This adds hierarchical transforms. Not particularly useful for quake itself at this stage, but it will allow for much more flexibility later on, especially when QuakeForge becomes more general-purpose.
2021-03-09 02:39:41 +00:00
vec4f_t Transform_GetLocalRotation (const transform_t *transform) __attribute__((pure));
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
void Transform_SetLocalRotation (transform_t *transform, vec4f_t rotation);
[entity] Start work on a new entity library The plan is to have a fully component based entity system. This adds hierarchical transforms. Not particularly useful for quake itself at this stage, but it will allow for much more flexibility later on, especially when QuakeForge becomes more general-purpose.
2021-03-09 02:39:41 +00:00
vec4f_t Transform_GetLocalScale (const transform_t *transform) __attribute__((pure));
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
void Transform_SetLocalScale (transform_t *transform, vec4f_t scale);
[entity] Start work on a new entity library The plan is to have a fully component based entity system. This adds hierarchical transforms. Not particularly useful for quake itself at this stage, but it will allow for much more flexibility later on, especially when QuakeForge becomes more general-purpose.
2021-03-09 02:39:41 +00:00
vec4f_t Transform_GetWorldPosition (const transform_t *transform) __attribute__((pure));
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
void Transform_SetWorldPosition (transform_t *transform, vec4f_t position);
[entity] Start work on a new entity library The plan is to have a fully component based entity system. This adds hierarchical transforms. Not particularly useful for quake itself at this stage, but it will allow for much more flexibility later on, especially when QuakeForge becomes more general-purpose.
2021-03-09 02:39:41 +00:00
vec4f_t Transform_GetWorldRotation (const transform_t *transform) __attribute__((pure));
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
void Transform_SetWorldRotation (transform_t *transform, vec4f_t rotation);
[entity] Start work on a new entity library The plan is to have a fully component based entity system. This adds hierarchical transforms. Not particularly useful for quake itself at this stage, but it will allow for much more flexibility later on, especially when QuakeForge becomes more general-purpose.
2021-03-09 02:39:41 +00:00
vec4f_t Transform_GetWorldScale (const transform_t *transform) __attribute__((pure));
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
void Transform_SetLocalTransform (transform_t *transform, vec4f_t scale,
vec4f_t rotation, vec4f_t position);
[entity] Start work on a new entity library The plan is to have a fully component based entity system. This adds hierarchical transforms. Not particularly useful for quake itself at this stage, but it will allow for much more flexibility later on, especially when QuakeForge becomes more general-purpose.
2021-03-09 02:39:41 +00:00
// NOTE: these use X: right, Y: forward, Z:up
// aslo, not guaranteed to be normalized or even orthogonal
vec4f_t Transform_Forward (const transform_t *transform) __attribute__((pure));
vec4f_t Transform_Right (const transform_t *transform) __attribute__((pure));
vec4f_t Transform_Up (const transform_t *transform) __attribute__((pure));
// no SetWorldScale because after rotations, non uniform scale becomes shear
///@}
[scene] Rename libQFentity to libQFscene And start working on scene management.
2021-07-24 05:19:52 +00:00
#endif//__QF_scene_transform_h
Reference in a new issue Copy permalink