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

673 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;
if (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);
}
[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 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;
entity_t *ent = 0;
rua_scene_t *scene = rua__scene_get (res, scene_id, name);
if (scene) {
pr_int_t entity_id = id >> 32;
ent = Scene_GetEntity (scene->scene, entity_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
if (!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
[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 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;
transform_t *transform = 0;
rua_scene_t *scene = rua_scene_get (res, scene_id);
if (scene) {
pr_int_t transform_id = id >> 32;
transform = Scene_GetTransform (scene->scene, transform_id);
}
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
if (!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);
[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
entity_t *ent = Scene_CreateEntity (scene->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
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);
entity_t *ent = rua_entity_get (res, id);
pr_ulong_t scene_id = id & 0xffffffff;
[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
R_RemoveEfrags (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
// bad scene caught above
rua_scene_t *scene = rua_scene_get (res, 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
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] 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 ent_id = P_ULONG (pr, 0);
entity_t *ent = rua_entity_get (res, 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] 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
// ent_id contains scene id
R_ULONG (pr) = MAKE_ID (ent->transform->id, 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);
entity_t *ent = rua_entity_get (res, ent_id);
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
R_RemoveEfrags (ent);
ent->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;
[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_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;
[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_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_t *child = Transform_GetChild (transform, P_UINT (pr, 2));
R_UINT (pr) = child ? child->id : 0;
}
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;
[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_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
Transform_SetParent (transform, parent);
}
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);
transform_t *transform = rua_transform_get (res, transform_id);
[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_t *parent = Transform_GetParent (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
// transform_id contains scene id
R_ULONG (pr) = 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;
[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_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;
[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_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;
[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_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;
[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_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;
[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_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;
[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_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;
[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_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
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;
[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_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;
[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_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
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;
[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_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;
[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_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
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;
[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_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;
[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_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
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;
[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_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;
[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_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
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;
[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_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;
[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_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;
[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_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
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;
[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_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;
[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_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;
[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_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] 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