qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-23 21:02:50 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/libs/ruamoko/rua_scene.c

676 lines
18 KiB
C
Raw Normal View History

[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
/*
bi_scene.c
Ruamoko scene builtins
Copyright (C) 2022 Bill Currie <bill@taniwha.org>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <stdlib.h>
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#include "QF/cmem.h"
#include "QF/hash.h"
[ruamoko] Allow entity model to be set And add header and function definitions for scene to libcsqc.
2022-05-04 08:38:38 +00:00
#include "QF/model.h"
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
#include "QF/progs.h"
[ruamoko] Allow entity model to be set And add header and function definitions for scene to libcsqc.
2022-05-04 08:38:38 +00:00
#include "QF/render.h"
#include "QF/plugin/vid_render.h"
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
[scene] Move entity_t etc into scene headers I meant to do this a while ago but forgot about it. Things are a bit of a mess in that the renderer knows too much about entities, but eventually the renderer will know about only things to render (meshes, particles, etc).
2022-03-29 05:40:48 +00:00
#include "QF/scene/entity.h"
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
#include "QF/scene/light.h"
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
#include "QF/scene/scene.h"
#include "QF/scene/transform.h"
#include "rua_internal.h"
typedef struct rua_scene_s {
struct rua_scene_s *next;
struct rua_scene_s **prev;
scene_t *scene;
} rua_scene_t;
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
typedef struct rua_lighting_s {
struct rua_lighting_s *next;
struct rua_lighting_s **prev;
lightingdata_t *ldata;
} rua_lighting_t;
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
typedef struct rua_scene_resources_s {
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
progs_t *pr;
PR_RESMAP (rua_scene_t) scene_map;
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
PR_RESMAP (rua_lighting_t) lighting_map;
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
rua_scene_t *scenes;
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
rua_lighting_t *ldatas;
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
} rua_scene_resources_t;
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
static rua_scene_t *
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_new (rua_scene_resources_t *res)
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
{
return PR_RESNEW (res->scene_map);
}
static void
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_free (rua_scene_resources_t *res, rua_scene_t *scene)
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
{
if (scene->next) {
scene->next->prev = scene->prev;
}
*scene->prev = scene->next;
scene->prev = 0;
PR_RESFREE (res->scene_map, scene);
}
[ruamoko] Pass some more purity tests Separate because I want to cherry-pick the other commit.
2022-02-14 10:56:56 +00:00
static rua_scene_t * __attribute__((pure))
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
rua__scene_get (rua_scene_resources_t *res, pr_ulong_t id, const char *name)
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
{
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
rua_scene_t *scene = 0;
[scene] Use hierref_t instead of transform_t in hierarchy Hierarchies are now much closer to being more general in that they are not tied to 3d transforms. This is a major step to moving the whole entity/transform system into an ECS.
2022-10-22 04:04:07 +00:00
id &= 0xffffffffu;
scene = PR_RESGET (res->scene_map, (pr_int_t) id);
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
// scene->prev will be null if the handle is unallocated
if (!scene || !scene->prev) {
PR_RunError (res->pr, "invalid scene passed to %s", name + 3);
}
return scene;
}
#define rua_scene_get(res, id) rua__scene_get(res, id, __FUNCTION__)
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
static int __attribute__((pure))
rua_scene_index (rua_scene_resources_t *res, rua_scene_t *scene)
{
return PR_RESINDEX (res->scene_map, scene);
}
[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
static entity_t __attribute__((pure))
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
rua__entity_get (rua_scene_resources_t *res, pr_ulong_t id, const char *name)
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
{
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
pr_ulong_t scene_id = id & 0xffffffff;
[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
entity_t ent = nullentity;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
rua_scene_t *scene = rua__scene_get (res, scene_id, name);
if (scene) {
pr_int_t entity_id = id >> 32;
[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
ent.id = entity_id;
[ruamoko] Fix missing entity registry pointer
2022-10-26 08:45:45 +00:00
ent.reg = scene->scene->reg;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
}
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
[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
if (!Entity_Valid (ent)) {
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
PR_RunError (res->pr, "invalid entity passed to %s", name + 3);
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
}
return ent;
}
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
#define rua_entity_get(res, id) rua__entity_get(res, id, __FUNCTION__)
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
[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
static transform_t __attribute__((pure))
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
rua__transform_get (rua_scene_resources_t *res, pr_ulong_t id, const char *name)
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
{
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
pr_ulong_t scene_id = id & 0xffffffff;
[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
transform_t transform = nulltransform;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
rua_scene_t *scene = rua_scene_get (res, scene_id);
if (scene) {
[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
entity_t transform_id = { .reg = scene->scene->reg, .id = id >> 32 };
transform = Entity_Transform (transform_id);
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
}
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
[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
if (!Transform_Valid (transform)) {
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
PR_RunError (res->pr, "invalid transform passed to %s", name + 3);
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
}
return transform;
}
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
#define rua_transform_get(res, id) rua__transform_get(res, id, __FUNCTION__)
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
static rua_lighting_t *
rua_lighting_new (rua_scene_resources_t *res)
{
return PR_RESNEW (res->lighting_map);
}
static void
rua_lighting_free (rua_scene_resources_t *res, rua_lighting_t *ldata)
{
if (ldata->next) {
ldata->next->prev = ldata->prev;
}
*ldata->prev = ldata->next;
ldata->prev = 0;
PR_RESFREE (res->lighting_map, ldata);
}
static rua_lighting_t * __attribute__((pure))
rua__lighting_get (rua_scene_resources_t *res, pr_ulong_t id, const char *name)
{
rua_lighting_t *ldata = 0;
if (id <= 0xffffffffu) {
ldata = PR_RESGET (res->lighting_map, (pr_int_t) id);
}
// ldata->prev will be null if the handle is unallocated
if (!ldata || !ldata->prev) {
PR_RunError (res->pr, "invalid lighting passed to %s", name + 3);
}
return ldata;
}
#define rua_lighting_get(res, id) rua__lighting_get(res, id, __FUNCTION__)
[ruamoko] Pass some more purity tests Separate because I want to cherry-pick the other commit.
2022-02-14 10:56:56 +00:00
static int __attribute__((pure))
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
rua_lighting_index (rua_scene_resources_t *res, rua_lighting_t *ldata)
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
{
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
return PR_RESINDEX (res->lighting_map, ldata);
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
}
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
#define MAKE_ID(id, sc_id) ((((pr_ulong_t) (id)) << 32) \
| ((sc_id) & 0xffffffff))
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
static void
bi_Scene_NewScene (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
rua_scene_t *scene = rua_scene_new (res);
scene->scene = Scene_NewScene ();
scene->next = res->scenes;
if (res->scenes) {
res->scenes->prev = &scene->next;
}
scene->prev = &res->scenes;
res->scenes = scene;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
// scene id in lower 32-bits for all handles
// zero upper 32-bits zero means scene, otherwise transform or entity
R_ULONG (pr) = MAKE_ID (0, rua_scene_index (res, scene));
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
}
static void
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_delete_scene (rua_scene_resources_t *res, rua_scene_t *scene)
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
{
Scene_DeleteScene (scene->scene);
rua_scene_free (res, scene);
}
static void
bi_Scene_DeleteScene (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
rua_scene_t *scene = rua_scene_get (res, P_ULONG (pr, 0));
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
rua_delete_scene (res, scene);
}
[ruamoko] Allow scenes to be fetched by C code Need to clean up that part of the API, though.
2022-05-05 12:26:18 +00:00
scene_t *
Scene_GetScene (progs_t *pr, pr_ulong_t handle)
{
if (!handle) {
return 0;
}
rua_scene_resources_t *res = PR_Resources_Find (pr, "Scene");
rua_scene_t *scene = rua_scene_get (res, P_ULONG (pr, 0));
return scene->scene;
}
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
static void
bi_Scene_CreateEntity (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
pr_ulong_t scene_id = P_ULONG (pr, 0);
rua_scene_t *scene = rua_scene_get (res, scene_id);
[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
entity_t ent = Scene_CreateEntity (scene->scene);
R_ULONG (pr) = MAKE_ID (ent.id, scene_id);
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
}
static void
bi_Scene_DestroyEntity (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
pr_ulong_t id = P_ULONG (pr, 0);
[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
entity_t ent = rua_entity_get (res, id);
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
pr_ulong_t scene_id = id & 0xffffffff;
[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
rua_scene_t *scene = rua_scene_get (res, scene_id);
[ruamoko] Clear efrags when destroying an entity This ensures the rendering system won't attempt to draw the entity after it has been destroyed.
2022-05-07 00:53:26 +00:00
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
// bad scene caught above
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
Scene_DestroyEntity (scene->scene, ent);
}
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
static void
bi_Scene_SetLighting (progs_t *pr, void *_res)
{
rua_scene_resources_t *res = _res;
pr_ulong_t scene_id = P_ULONG (pr, 0);
rua_scene_t *scene = rua_scene_get (res, scene_id);
pr_ulong_t ldata_id = P_ULONG (pr, 1);
rua_lighting_t *ldata = 0;
if (ldata_id) {
ldata = rua_lighting_get (res, ldata_id);
}
scene->scene->lights = ldata->ldata;
}
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
static void
bi_Entity_GetTransform (progs_t *pr, void *_res)
{
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
pr_ulong_t ent_id = P_ULONG (pr, 0);
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
[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
// ent_id is used to fetch the transform every time
R_ULONG (pr) = ent_id;
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
}
[ruamoko] Allow entity model to be set And add header and function definitions for scene to libcsqc.
2022-05-04 08:38:38 +00:00
static void
bi_Entity_SetModel (progs_t *pr, void *_res)
{
rua_scene_resources_t *res = _res;
pr_ulong_t ent_id = P_ULONG (pr, 0);
pr_int_t model_id = P_INT (pr, 1);
[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
entity_t ent = rua_entity_get (res, ent_id);
[ruamoko] Allow entity model to be set And add header and function definitions for scene to libcsqc.
2022-05-04 08:38:38 +00:00
model_t *model = Model_GetModel (pr, model_id);
[ruamoko] Allow scenes to be fetched by C code Need to clean up that part of the API, though.
2022-05-05 12:26:18 +00:00
pr_ulong_t scene_id = ent_id & 0xffffffff;
// bad scene caught above
rua_scene_t *scene = rua_scene_get (res, scene_id);
[ruamoko] Allow entity model to be set And add header and function definitions for scene to libcsqc.
2022-05-04 08:38:38 +00:00
[scene] Move visibility management into scene code Well, sort of: it's still really in the renderer, but now calling R_AddEfrags automatically updates the visibility structure as necessary, and deleting an entity cleans up the efrags automatically. I wanted this over twenty years ago.
2022-11-13 06:08:18 +00:00
renderer_t *renderer = Ent_GetComponent (ent.id, scene_renderer, ent.reg);
[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
renderer->model = model;
[ruamoko] Allow scenes to be fetched by C code Need to clean up that part of the API, though.
2022-05-05 12:26:18 +00:00
R_AddEfrags (&scene->scene->worldmodel->brush, ent);
[ruamoko] Allow entity model to be set And add header and function definitions for scene to libcsqc.
2022-05-04 08:38:38 +00:00
}
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
static void
bi_Transform_ChildCount (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_UINT (pr) = Transform_ChildCount (transform);
}
static void
bi_Transform_GetChild (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
pr_ulong_t transform_id = P_ULONG (pr, 0);
transform_t transform = rua_transform_get (res, transform_id);
transform_t child = Transform_GetChild (transform, P_UINT (pr, 2));
R_ULONG (pr) = Transform_Valid (child) ? MAKE_ID (child.id, transform_id)
: 0;
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
}
static void
bi_Transform_SetParent (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
transform_t parent = rua_transform_get (res, P_ULONG (pr, 1));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +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
Transform_SetParent (transform, parent);
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
}
static void
bi_Transform_GetParent (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
pr_ulong_t transform_id = P_ULONG (pr, 0);
[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
transform_t transform = rua_transform_get (res, transform_id);
transform_t parent = Transform_GetParent (transform);
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
// transform_id contains scene id
[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
R_ULONG (pr) = Transform_Valid (parent) ? MAKE_ID (parent.id, transform_id)
: 0;
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
}
static void
bi_Transform_SetTag (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
pr_uint_t tag = P_UINT (pr, 2);
Transform_SetTag (transform, tag);
}
static void
bi_Transform_GetTag (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_UINT (pr) = Transform_GetTag (transform);
}
static void
bi_Transform_GetLocalMatrix (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
Transform_GetLocalMatrix (transform, &R_PACKED (pr, pr_vec4_t));
}
static void
bi_Transform_GetLocalInverse (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
Transform_GetLocalInverse (transform, &R_PACKED (pr, pr_vec4_t));
}
static void
bi_Transform_GetWorldMatrix (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
Transform_GetWorldMatrix (transform, &R_PACKED (pr, pr_vec4_t));
}
static void
bi_Transform_GetWorldInverse (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
Transform_GetWorldInverse (transform, &R_PACKED (pr, pr_vec4_t));
}
static void
bi_Transform_SetLocalPosition (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
Transform_SetLocalPosition (transform, P_PACKED (pr, pr_vec4_t, 1));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
}
static void
bi_Transform_GetLocalPosition (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_PACKED (pr, pr_vec4_t) = Transform_GetLocalPosition (transform);
}
static void
bi_Transform_SetLocalRotation (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
Transform_SetLocalRotation (transform, P_PACKED (pr, pr_vec4_t, 1));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
}
static void
bi_Transform_GetLocalRotation (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_PACKED (pr, pr_vec4_t) = Transform_GetLocalRotation (transform);
}
static void
bi_Transform_SetLocalScale (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
Transform_SetLocalScale (transform, P_PACKED (pr, pr_vec4_t, 1));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
}
static void
bi_Transform_GetLocalScale (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_PACKED (pr, pr_vec4_t) = Transform_GetLocalScale (transform);
}
static void
bi_Transform_SetWorldPosition (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
Transform_SetWorldPosition (transform, P_PACKED (pr, pr_vec4_t, 1));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
}
static void
bi_Transform_GetWorldPosition (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_PACKED (pr, pr_vec4_t) = Transform_GetWorldPosition (transform);
}
static void
bi_Transform_SetWorldRotation (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
Transform_SetWorldRotation (transform, P_PACKED (pr, pr_vec4_t, 1));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
}
static void
bi_Transform_GetWorldRotation (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_PACKED (pr, pr_vec4_t) = Transform_GetWorldRotation (transform);
}
static void
bi_Transform_GetWorldScale (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_PACKED (pr, pr_vec4_t) = Transform_GetWorldScale (transform);
}
static void
bi_Transform_SetLocalTransform (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
Transform_SetLocalTransform (transform, P_PACKED (pr, pr_vec4_t, 1),
P_PACKED (pr, pr_vec4_t, 2), P_PACKED (pr, pr_vec4_t, 3));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
}
static void
bi_Transform_Forward (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_PACKED (pr, pr_vec4_t) = Transform_Forward (transform);
}
static void
bi_Transform_Right (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_PACKED (pr, pr_vec4_t) = Transform_Right (transform);
}
static void
bi_Transform_Up (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[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
transform_t transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_PACKED (pr, pr_vec4_t) = Transform_Up (transform);
}
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
static void
bi_Light_CreateLightingData (progs_t *pr, void *_res)
{
rua_scene_resources_t *res = _res;
pr_ulong_t scene_id = P_ULONG (pr, 0);
rua_scene_t *scene = rua_scene_get (res, scene_id);
rua_lighting_t *ldata = rua_lighting_new (res);
ldata->ldata = Light_CreateLightingData (scene->scene);
ldata->next = res->ldatas;
if (res->ldatas) {
res->ldatas->prev = &ldata->next;
}
ldata->prev = &res->ldatas;
res->ldatas = ldata;
// ldata id in lower 32-bits for all handles
// upper 32-bits reserved
R_ULONG (pr) = MAKE_ID (0, rua_lighting_index (res, ldata));
}
static void
rua_delete_lighting (rua_scene_resources_t *res, rua_lighting_t *ldata)
{
Light_DestroyLightingData (ldata->ldata);
rua_lighting_free (res, ldata);
}
static void
bi_Light_DestroyLightingData (progs_t *pr, void *_res)
{
rua_scene_resources_t *res = _res;
rua_lighting_t *ldata = rua_lighting_get (res, P_ULONG (pr, 0));
rua_delete_lighting (res, ldata);
}
static void
bi_Light_ClearLights (progs_t *pr, void *_res)
{
rua_scene_resources_t *res = _res;
rua_lighting_t *ldata = rua_lighting_get (res, P_ULONG (pr, 0));
Light_ClearLights (ldata->ldata);
}
static void
bi_Light_AddLight (progs_t *pr, void *_res)
{
rua_scene_resources_t *res = _res;
rua_lighting_t *ldata = rua_lighting_get (res, P_ULONG (pr, 0));
light_t *light = &P_PACKED (pr, light_t, 1);
int style = P_INT (pr, 5);
Light_AddLight (ldata->ldata, light, style);
}
static void
bi_Light_EnableSun (progs_t *pr, void *_res)
{
rua_scene_resources_t *res = _res;
rua_lighting_t *ldata = rua_lighting_get (res, P_ULONG (pr, 0));
Light_EnableSun (ldata->ldata);
}
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
#define p(type) PR_PARAM(type)
#define P(a, s) { .size = (s), .alignment = BITOP_LOG2 (a), }
#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}}
static builtin_t builtins[] = {
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
bi(Scene_NewScene, 0),
bi(Scene_DeleteScene, 1, p(ulong)),
bi(Scene_CreateEntity, 1, p(ulong)),
bi(Scene_DestroyEntity, 1, p(ulong)),
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
bi(Scene_SetLighting , 2, p(ulong), p(ulong)),
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
bi(Entity_GetTransform, 1, p(ulong)),
[ruamoko] Allow entity model to be set And add header and function definitions for scene to libcsqc.
2022-05-04 08:38:38 +00:00
bi(Entity_SetModel, 2, p(ulong), p(int)),
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
bi(Transform_ChildCount, 1, p(ulong)),
bi(Transform_GetChild, 2, p(ulong), p(int)),
bi(Transform_SetParent, 2, p(ulong), p(ulong)),
bi(Transform_GetParent, 1, p(ulong)),
bi(Transform_SetTag, 2, p(ulong), p(uint)),
bi(Transform_GetTag, 1, p(ulong)),
bi(Transform_GetLocalMatrix, 1, p(ulong)),
bi(Transform_GetLocalInverse, 1, p(ulong)),
bi(Transform_GetWorldMatrix, 1, p(ulong)),
bi(Transform_GetWorldInverse, 1, p(ulong)),
bi(Transform_SetLocalPosition, 2, p(ulong), p(vec4)),
bi(Transform_GetLocalPosition, 1, p(ulong)),
bi(Transform_SetLocalRotation, 2, p(ulong), p(vec4)),
bi(Transform_GetLocalRotation, 1, p(ulong)),
bi(Transform_SetLocalScale, 2, p(ulong), p(vec4)),
bi(Transform_GetLocalScale, 1, p(ulong)),
bi(Transform_SetWorldPosition, 2, p(ulong), p(vec4)),
bi(Transform_GetWorldPosition, 1, p(ulong)),
bi(Transform_SetWorldRotation, 2, p(ulong), p(vec4)),
bi(Transform_GetWorldRotation, 1, p(ulong)),
bi(Transform_GetWorldScale, 1, p(ulong)),
bi(Transform_SetLocalTransform, 4, p(ulong), p(vec4), p(vec4), p(vec4)),
bi(Transform_Forward, 1, p(ulong)),
bi(Transform_Right, 1, p(ulong)),
bi(Transform_Up, 1, p(ulong)),
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
bi(Light_CreateLightingData, 1, p(ulong)),
bi(Light_DestroyLightingData, 1, p(ulong)),
bi(Light_ClearLights, 1, p(ulong)),
bi(Light_AddLight, 5, p(ulong),// really, 3
p(vec4), p(vec4), p(vec4), p(vec4), p(int)),
bi(Light_EnableSun, 1, p(ulong)),
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
{0}
};
static void
bi_scene_clear (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
[ruamoko] Clean up lighting data blocks Don't want to leak memory.
2022-05-05 23:26:55 +00:00
while (res->ldatas) {
rua_delete_lighting (res, res->ldatas);
}
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
while (res->scenes) {
rua_delete_scene (res, res->scenes);
}
}
[gamecode] Add PR_Shutdown for tearing down a VM This is meant for a "permanent" tear-down before freeing the memory holding the VM state or at program shutdown. As a consequence, builtin sub-systems registering resources are now required to pass a "destroy" function pointer that will be called just before the memory holding those resources is freed by the VM resource manager (ie, the manager owns the resource memory block, but each subsystem is responsible for cleaning up any resources held within that block). This even enhances thread-safety in rua_obj (there are some problems with cmd, cvar, and gib).
2022-05-12 09:23:32 +00:00
static void
bi_scene_destroy (progs_t *pr, void *_res)
{
[ruamoko] Plug yet more memory leaks Some of them, especially in rua_obj, were quite legitimate and even a problem for thread-safety (rua_cmd is currently not thread-safe, but it needs a lock, which I don't feel like doing at this stage).
2023-03-05 08:20:04 +00:00
rua_scene_resources_t *res = _res;
PR_RESDELMAP (res->scene_map);
PR_RESDELMAP (res->lighting_map);
free (res);
[gamecode] Add PR_Shutdown for tearing down a VM This is meant for a "permanent" tear-down before freeing the memory holding the VM state or at program shutdown. As a consequence, builtin sub-systems registering resources are now required to pass a "destroy" function pointer that will be called just before the memory holding those resources is freed by the VM resource manager (ie, the manager owns the resource memory block, but each subsystem is responsible for cleaning up any resources held within that block). This even enhances thread-safety in rua_obj (there are some problems with cmd, cvar, and gib).
2022-05-12 09:23:32 +00:00
}
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
void
RUA_Scene_Init (progs_t *pr, int secure)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = calloc (sizeof (rua_scene_resources_t), 1);
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
res->pr = pr;
[gamecode] Add PR_Shutdown for tearing down a VM This is meant for a "permanent" tear-down before freeing the memory holding the VM state or at program shutdown. As a consequence, builtin sub-systems registering resources are now required to pass a "destroy" function pointer that will be called just before the memory holding those resources is freed by the VM resource manager (ie, the manager owns the resource memory block, but each subsystem is responsible for cleaning up any resources held within that block). This even enhances thread-safety in rua_obj (there are some problems with cmd, cvar, and gib).
2022-05-12 09:23:32 +00:00
PR_Resources_Register (pr, "Scene", res, bi_scene_clear, bi_scene_destroy);
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
PR_RegisterBuiltins (pr, builtins, res);
}
Reference in a new issue Copy permalink